rk_util.c

Go to the documentation of this file.

/*
 * rk_util.c
 *
 * 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.c
 *
 * Implementation of the functions in rk_util.h.
 */

#include "config.h"

#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <fcntl.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/types.h>

#include "assert_pp.h"
#include "instrumentation.h"

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

/* BEGIN Instrumentation data */

#if defined(INSTR_rk_resource_set_get_usage_data)
static struct iPoint INSTR_get_point = {
    INSTR_rk_resource_set_get_usage_data,
};
#endif

#if defined(INSTR_rk_proc_usage_data)
static struct iPoint INSTR_rk_proc_usage_point = {
    INSTR_rk_proc_usage_data,
};
#endif

/* END Instrumentation data */

rk_resource_set_t rk_resource_set_get_by_name(const char *name)
{
    rk_resource_set_t retval = NULL_RESOURCE_SET;
#define MAX_RK_SETS 128
    rk_resource_set_t rk_sets[MAX_RK_SETS];
    char rs_name[RK_NAME_LEN + 1];
    int lpc, actual;

    require(name != NULL);
    
    actual = rk_resource_sets_get_list(rk_sets, MAX_RK_SETS);
    for( lpc = 0; (lpc < actual) && (retval == NULL_RESOURCE_SET); lpc++ )
    {
        rs_name[0] = '\0';
        if( (rk_resource_set_get_name(rk_sets[lpc], rs_name) == 0) &&
            (strcmp(rs_name, name) == 0) )
        {
            retval = rk_sets[lpc];
        }
    }
#undef MAX_RK_SETS
    return( retval );
}

/**
 * Function for comparing two rk_resource_set_proc objects.  Required for
 * quicksort.
 *
 * @param a The left hand side of the comparison.
 * @param b The right hand side of the comparison.
 * @return Zero if "a" and "b" are equal, -1 if "a" is less than "b", and 1 if
 * "a" is greater than "b".
 */
static int rk_resource_set_proc_compare(const void *a, const void *b)
{
    rk_resource_set_proc_t pca, pcb;
    int retval = 0;

    require(a != NULL);
    require(b != NULL);

    pca = (rk_resource_set_proc_t)a;
    pcb = (rk_resource_set_proc_t)b;
    
    if( pca->pid < pcb->pid )
        retval = -1;
    else if( pca->pid == pcb->pid )
        retval = 0;
    else if( pca->pid > pcb->pid )
        retval = 1;

    ensure(retval >= -1);
    ensure(retval <=  1);
    
    return( retval );
}

/**
 * Search for a particular process ID in a process cache.
 *
 * @param pc The process cache to search.
 * @param pid The process ID to search for.
 * @return The index in the process cache array where the process ID was found
 * or -1 if the process does not exist in the array.
 */
static int rk_resource_set_proc_cache_search(rk_resource_set_proc_cache_t pc,
                                             pid_t pid)
{
    int high, low = 0, probe, retval;

    require(pc != NULL);
    require(pc->data != NULL);
    require(pc->used <= pc->length);
    require(pid != 0);

    /* The array is sorted so we do a binary search. */
    high = pc->used;
    while( low <= (high - 1) )
    {
        probe = (low + high) / 2;
        if( pid > pc->data[probe].pid )
            low = probe + 1;
        else
            high = probe;
    }
    if( (high >= pc->used) || (pc->data[high].pid != pid) )
    {
        retval = -1;
    }
    else
    {
        retval = high;
    }

    ensure(retval >= -1);
    ensure((retval == -1) || (retval < pc->used));
    ensure((retval == -1) || (pc->data[retval].pid == pid));
    
    return( retval );
}

/**
 * Add an element to a process cache.
 *
 * @param pc The process cache to add an element to.
 * @param pid The process ID to add.
 * @return The index in the process cache array where the new element can be
 * found.
 */
static int rk_resource_set_proc_cache_add(rk_resource_set_proc_cache_t pc,
                                          pid_t pid)
{
    int retval = -1;

    require(pc != NULL);
    require(pc->data != NULL);
    require(pc->used <= pc->length);
    require(pid != 0);

    /* Make sure there is enough room. */
    if( pc->used < pc->length )
    {
        int index;

        /* Allocate an element, */
        index = pc->used;
        pc->used += 1;
        /* ... fill in the fields, */
        pc->data[index].pid = pid;
        pc->data[index].fd = -1;
        pc->data[index].cpu_usage = 0;
        /* ... resort the array, and */
        qsort(pc->data,
              pc->used,
              sizeof(struct rk_resource_set_proc),
              rk_resource_set_proc_compare);
        /* ... find the new location for the element. */
        retval = rk_resource_set_proc_cache_search(pc, pid);
    }

    ensure(retval >= -1);
    ensure(retval < pc->used);
    ensure((retval == -1) || (pc->data[retval].pid == pid));
    
    return( retval );
}

/**
 * Intersect the process cache array with a list of the currently active
 * process IDs.
 *
 * @param pc The process cache to intersect.
 * @param procs The list process IDs to intersect with the process cache.
 * @param procs_length The length of the "procs" array.
 */
static unsigned long long rk_resource_set_proc_cache_intersect(
        rk_resource_set_proc_cache_t pc, pid_t *procs, size_t procs_length)
{
    unsigned long long retval = 0;
    unsigned int lpc;

    require(pc != NULL);
    require(pc->data != NULL);
    require(pc->used <= pc->length);
    require(procs != NULL);

    for( lpc = 0; lpc < pc->used; )
    {
        int lpc2;

        /* Try to find the cached ID in the active list and */
        for( lpc2 = 0;
             (lpc2 < procs_length) && (procs[lpc2] != pc->data[lpc].pid);
             lpc2++ )
        {
        }
        /* ... remove it if it is not found. */
        if( lpc2 == procs_length )
        {
            close(pc->data[lpc].fd);
            retval += pc->data[lpc].cpu_usage;
            pc->data[lpc] = pc->data[lpc + 1];
            pc->used -= 1;
        }
        else
        {
            lpc += 1;
        }
    }
    return( retval );
}

int rk_resource_set_get_usage(rk_resource_set_t rs,
                              rk_resource_set_usage_t rsu_inout,
                              rk_resource_set_proc_cache_t pc_inout)
{
    int retval = 0;

    if( (rs == NULL) || (rsu_inout == NULL) )
    {
        retval = EINVAL;
    }
    else if( (pc_inout != NULL) && (pc_inout->used > pc_inout->length) )
    {
        retval = EINVAL;
    }
    else
    {
#define MAX_PID_COUNT 128
        pid_t procs[MAX_PID_COUNT];
        int lpc;
        
        /* Get the list of active processes and */
        rsu_inout->proc_count =
            rk_resource_set_get_proclist(rs, procs, MAX_PID_COUNT);
        rsu_inout->active_cpu_usage = 0;
        /* ... compute their total CPU usage. */
        for( lpc = 0;
             (lpc < rsu_inout->proc_count) && (retval == 0);
             lpc++ )
        {
            int index = -1, file = -1, cached;
            char scratch[1024]; // XXX
            
            /* Try to get a handle on the process' "stat" file and */
            if( (pc_inout == NULL) ||
                (index = rk_resource_set_proc_cache_search(
                pc_inout, procs[lpc])) == -1 )
            {
                /* The file is not yet cached, open it and */
                snprintf(scratch,
                         sizeof(scratch),
                         "/proc/%d/stat",
                         procs[lpc]);
                if( (file = open(scratch, O_RDONLY)) == -1 )
                {
                    cached = 0;
                    retval = errno;
                }
                /* ... try to add it to the cache. */
                else if( (pc_inout == NULL) ||
                         (index = rk_resource_set_proc_cache_add(
                        pc_inout,
                        procs[lpc])) == -1 )
                {
                    cached = 0;
                }
                else
                {
                    pc_inout->data[index].fd = file;
                    cached = 1;
                }
            }
            else
            {
                file = pc_inout->data[index].fd;
                if( lseek(file, 0, SEEK_SET) == -1 )
                {
                    perror("lseek");
                    ensure(0);
                }
                cached = 1;
            }
            /* ... read the CPU usage. */
            if( file != -1 )
            {
                unsigned long long usage = 0;
                struct timeval utime, stime;
                off_t off = 0;
                int rc;
                
                memset(&utime, 0, sizeof(utime));
                memset(&stime, 0, sizeof(stime));
                
                while( (rc = read(file,
                                  &scratch[off],
                                  sizeof(scratch) - off)) > 0 )
                {
                    off += rc;
                    if( scratch[off - 1] == '\n' ) break;
                }
                if( rc == -1 )
                {
                    retval = errno;
                }
                else
                {
                    int index, saved_index, space_count = 0, len;
                    
                    scratch[off] = '\0';
                    len = strlen(scratch);
                    /* BEGIN Hack */
                    /*
                     * Alas, there is some glitch that causes extra data
                     * to be read, so we have to back track a bit to try
                     * and avoid it.
                     */
                    saved_index = len - 1;
                    for( index = len - 1; index > (len - 20); index-- )
                    {
                        if( scratch[index] == '\n' )
                            saved_index = index;
                    }
                    /* END Hack */
                    index = saved_index;
                    for( ; space_count < 4; index-- )
                    {
                        if( isspace(scratch[index]) )
                        {
                            space_count += 1;
                        }
                    }
                    if( sscanf(&scratch[index],
                               "%ld %ld %ld %ld",
                               &utime.tv_sec,
                               &utime.tv_usec,
                               &stime.tv_sec,
                               &stime.tv_usec) != 4 )
                    {
                        fprintf(stderr,
                                "BEGIN oscratch\n%s\nEND\n",
                                scratch);
                        fprintf(stderr, "scratch %s\n", &scratch[index]);
                        retval = ENOSYS;
                    }
                }
                
                usage += utime.tv_sec * 1000000;
                usage += utime.tv_usec;
                usage += stime.tv_sec * 1000000;
                usage += stime.tv_usec;
                INSTR_rk_proc_usage(&INSTR_rk_proc_usage_point, usage);
                rsu_inout->active_cpu_usage += usage;
                if( index >= 0 )
                {
                    pc_inout->data[index].cpu_usage = usage;
                }
                if( !cached )
                {
                    close(file);
                }
            }
        }
        /*
         * If the set of processes has changed, remove any dead ones from
         * the cache.
         */
        if( (pc_inout != NULL) &&
            (pc_inout->used > rsu_inout->proc_count) )
        {
            rsu_inout->inactive_cpu_usage +=
                rk_resource_set_proc_cache_intersect(pc_inout,
                                                     procs,
                                                     rsu_inout->proc_count);
        }
    }
    return( retval );
}

void rk_resource_set_proc_cache_release(rk_resource_set_proc_cache_t pc)
{
    int lpc;
    
    require(pc != NULL);
    require(pc->data != NULL);
    require(pc->used <= pc->length);
    
    for( lpc = 0; lpc < pc->used; lpc++ )
    {
        close(pc->data[lpc].fd);
        pc->data[lpc].fd = -1;
    }
    pc->used = 0;
    pc = NULL;
}

---