rk_util_test.c

Go to the documentation of this file.

/*
 * rk_util_test.h
 *
 * Copyright (c) 2003, 2004 The University of Utah and the Flux Group.
 * All rights reserved.
 *
 * This file is licensed under the terms of the GNU Public License.  
 * See the file "license.terms" for restrictions on redistribution 
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */

/**
 * @file rk_util_test.c
 *
 * Test cases for the functions in rk_util.h.
 */

#include "config.h"

#ifndef DEBUG
#define DEBUG
#endif

#include <string.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>

#include <assert_pp.h>
#include <instrumentation.h>

#include <rk/rk.h>
#include "rk_util.h"

/**
 * Test the rk_resource_set_get_usage function.
 *
 * @param rs The resource set to query.
 * @param rsu The object to store the resource set usage data.
 * @param pc The process cache to use when querying the set.
 * @return True if the test succeeded, false otherwise.
 */
static int test_get_usage(rk_resource_set_t rs,
                          rk_resource_set_usage_t rsu,
                          rk_resource_set_proc_cache_t pc)
{
    unsigned long long last_usage = 0;
    unsigned int consecutive = 0;
    int lpc, rc, retval = 1;

    require(rs != NULL_RESOURCE_SET);
    require(rsu != NULL);
    
    for( lpc = 0; (lpc < 10000) && (retval == 1); lpc++ )
    {
        volatile int lpc2;
                
        rc = rk_resource_set_get_usage(rs, rsu, pc);

        if( rc != 0 )
            printf("%s\n", strerror(rc));
        require(rc == 0);
        require(rsu->proc_count == 1);
        require(rsu->inactive_cpu_usage == 0);

        if( rsu->active_cpu_usage < last_usage )
        {
            retval = 0;
        }
        else if( rsu->active_cpu_usage == last_usage )
        {
            consecutive += 1;
        }
        if( consecutive > 20 )
        {
            retval = 0;
        }
        else
        {
            consecutive = 0;
        }
        last_usage = rsu->active_cpu_usage;
        
        for( lpc2 = 0; lpc2 < 1000; lpc2++ );
    }
    return( retval );
}

int main(int argc, char *argv[])
{
    int retval = EXIT_FAILURE;
    rk_resource_set_t rs;

    instrumentation_data.iid_OutputFileName = "-";
    atexit(iPrintPointsAtExit);

    if( (rs = rk_resource_set_create("rk_util_test")) != NULL_RESOURCE_SET )
    {
        struct rk_resource_set_usage rsu;

        /**
         * @test The rk_resource_set_get_by_name function with an existing
         * resource set.
         */
        require(rk_resource_set_get_by_name("rk_util_test") !=
                NULL_RESOURCE_SET);
        /**
         * @test The rk_resource_set_get_by_name function with a non-existent
         * resource set.
         */
        require(rk_resource_set_get_by_name("non-existent") ==
                NULL_RESOURCE_SET);

        rsu.proc_count = 1;
        rsu.inactive_cpu_usage = 0;
        rsu.active_cpu_usage = 1;
        /**
         * @test The rk_resource_set_get_usage function when there are no
         * processes in the set.
         */
        if( rk_resource_set_get_usage(rs, &rsu, NULL) == 0 )
        {
            ensure(rsu.proc_count == 0);
            ensure(rsu.active_cpu_usage == 0);
        }
        if( rk_resource_set_attach_process(rs, getpid()) != 0 )
        {
            perror("rk_resource_set_attach_process");
        }
        else
        {
            struct rk_resource_set_proc proc_elements[1];
            struct rk_resource_set_proc_cache pc;

            memset(proc_elements, 0, sizeof(proc_elements));
            pc.data = proc_elements;
            pc.used = 0;
            pc.length = 1;

            /**
             * @test The rk_resource_set_get_usage function with no process
             * cache.
             */
            if( !test_get_usage(rs, &rsu, NULL) )
            {
                retval = EXIT_FAILURE;
            }
            /**
             * @test The rk_resource_set_get_usage function with a process
             * cache.
             */
            else if( !test_get_usage(rs, &rsu, &pc) )
            {
                retval = EXIT_FAILURE;
            }
            /**
             * @test The rk_resource_set_get_usage function with a process
             * cache after the processes have been removed.
             */
            else if( rk_resource_set_detach_process(rs, getpid()) != 0 )
            {
                perror("rk_resource_set_detach_process");
            }
            else
            {
                unsigned long long old_usage;
                int rc;

                old_usage = rsu.active_cpu_usage;
                rc = rk_resource_set_get_usage(rs, &rsu, &pc);

                ensure(rsu.proc_count == 0);
                ensure(rsu.inactive_cpu_usage == old_usage);
                ensure(rsu.active_cpu_usage == 0);
                
                retval = EXIT_SUCCESS;
            }

            rk_resource_set_proc_cache_release(&pc);
        }
        rk_resource_set_destroy(rs);
    }
    else
    {
        perror("rk_resource_set_create");
    }
    return( retval );
}

---