instrumentation.c

Go to the documentation of this file.

/*
 * instrumentation.c
 *
 * Copyright (c) 2003 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 instrumentation.c
 *
 * Implementation of the functions in instrumentation.h.
 */

#include "config.h"

#include <sys/types.h>
#include <string.h>
#include <unistd.h>
#include <float.h>
#include <assert_pp.h>

#include "instrumentation.h"

/**
 * Add an amount to an existing index into the ip_History.data array of the
 * iPoint structure.  In case the addition causes the index to extend beyond
 * the bounds of the array, the result will be wrapped around to the beginning.
 *
 * @param ip A pointer to a valid iPoint.
 * @param amount The amount to add to the ip_History.start value.
 * @return The new index.
 */
#define IP_HISTORY_START_ADD(ip, amount) \
    ((ip)->ip_History.start + (amount)) % (ip)->ip_History.length

/**
 * The default name for the instrumentation file.
 */
static const char *DEFAULT_INSTRUMENTATION_FILE_NAME =
    PACKAGE "-instrumentation-%d.txt";

struct iInstrumentationData instrumentation_data;

static void iInitPoint(struct iPoint *ip)
{
    require(ip != NULL);
    require(ip->ip_Name != NULL);

    ip->ip_Minimum = FLT_MAX;
    ip->ip_Maximum = FLT_MIN;
    if( ip->ip_Format == NULL )
    {
        ip->ip_Format = "%10.2f  ";
    }
    if( ip->ip_Succ == NULL )
    {
        if( instrumentation_data.iid_FirstPoint == NULL )
        {
            instrumentation_data.iid_FirstPoint =
                &instrumentation_data.iid_NullPoint;
        }
        ip->ip_Succ = instrumentation_data.iid_FirstPoint;
        instrumentation_data.iid_FirstPoint = ip;
    }
}

void iPostFloatData(struct iPoint *ip, double value)
{
    require(ip != NULL);

    if( ip->ip_Count == 0 )
    {
        /* The first recorded value, initialize any defaults. */
        iInitPoint(ip);
    }
    if( ip->ip_History.data != NULL )
    {
        if( ip->ip_Count >= ip->ip_History.length )
        {
            ip->ip_History.lost += 1;
            if( ip->ip_Flags & IPF_DROP_HISTORY_START )
            {
                ip->ip_History.data[ip->ip_History.start] = value;
                ip->ip_History.start = IP_HISTORY_START_ADD(ip, 1);
            }
        }
        else
        {
            ip->ip_History.data[ip->ip_Count] = value;
        }
    }
    ip->ip_Count += 1;
    ip->ip_Total += value;
    if( value < ip->ip_Minimum )
    {
        ip->ip_Minimum = value;
    }
    if( value > ip->ip_Maximum )
    {
        ip->ip_Maximum = value;
    }
}

void iPrintPoint(FILE *file, struct iPoint *ip)
{
    require(file != NULL);
    require(ip != NULL);
    require(ip->ip_Name != NULL);

    fprintf(file,
            "%s: count=%qd total=%f min=%f max=%f avg=%f  '%s'\n",
            ip->ip_Name,
            ip->ip_Count,
            ip->ip_Total,
            ip->ip_Minimum,
            ip->ip_Maximum,
            ip->ip_Total / ((double)ip->ip_Count),
            ip->ip_Description != NULL ? ip->ip_Description : "");
    if( ip->ip_History.data != NULL )
    {
        int lpc;

        if( ip->ip_History.lost > 0 )
        {
            fprintf(file,
                    "\tLost %d data points at the start\n",
                    ip->ip_History.lost);
        }
        for( lpc = 0;
             (lpc < ip->ip_Count) && (lpc < ip->ip_History.length);
             )
        {
            int row_count;
            
            fprintf(file, "\t");
            for( row_count = 0;
                 (row_count < 5) &&
                     (lpc < ip->ip_Count) &&
                     (lpc < ip->ip_History.length);
                 row_count++, lpc++ )
            {
                fprintf(file,
                        ip->ip_Format,
                        ip->ip_History.data[IP_HISTORY_START_ADD(ip, lpc)]);
            }
            fprintf(file, "\n");
        }
    }
}

void iPrintPoints(FILE *file)
{
    struct iPoint *ip;
    
    require(file != NULL);

    ip = instrumentation_data.iid_FirstPoint;
    while( (ip != NULL) && (ip != &instrumentation_data.iid_NullPoint) )
    {
        iPrintPoint(file, ip);
        ip = ip->ip_Succ;
    }
}

void iPrintPointsAtExit(void)
{
    FILE *file;

    if( instrumentation_data.iid_OutputFileName != NULL )
    {
        if( strcmp("-", instrumentation_data.iid_OutputFileName) == 0 )
        {
            file = stdout;
        }
        else
        {
            file = fopen(instrumentation_data.iid_OutputFileName, "w");
        }
    }
    else
    {
        static char formatted_filename[
                sizeof(DEFAULT_INSTRUMENTATION_FILE_NAME) + 8];
        
        sprintf(formatted_filename,
                DEFAULT_INSTRUMENTATION_FILE_NAME,
                getpid());
        file = fopen(formatted_filename, "w");
    }
    if( file != NULL )
    {
        iPrintPoints(file);
        fclose(file);
    }
    else
    {
        fprintf(stderr,
                "Warning: unable to create instrumentation file.\n");
    }
}

---