/* * File Name: timer.c * Purpose: Provides timing routines for the DIS Data Management * Benchmark application. Preprocessor directives are setup to * allow either the ANSI/ISO C standard time() routine to be * used or the BSD Unix gettimeofday() routine to be used. The * gettimeofday() routine has a fidelity of microseconds while * the ANSI/ISO time() routine is only seconds. The Data * Management baseline data sets will generally require a * better timing resolution than seconds, but nothing exists * within the ANSI/ISO C standard which provides the required * fidelity. Because the DIS hardware teams are only required * to conform to the ANSI/ISO C standard libraries and this * will cause inaccuracies in the metric statistics, a * compromise is implemented. If USE_GETTIMEOFDAY is defined * (not TRUE/FALSE, just defined), the metrics will use the * Unix standard gettimeofday() promoting the microseconds to * milliseconds to allow storage in a long integer. If * USE_GETTIMEOFDAY is not defined, the metrics will use the * ANSI/ISO C standard time() routine. This will generally * invalidate the metric statistical values for individual * commands, but may provide a relatively accurate overall * time required to complete the data set. * * Modifications required to run the program on different * hardware systems with different system timing routines * should only need to change this function. As long as the * getTime() routine returns milliseconds from program start, * the rest of the baseline source code should function * correctly. * * Revision History: * Date Name Revision * ------- --------------- ------------------------------ * 27May99 Matthew Rivas Created * 04Jun99 Matthew Rivas Added SECONDS_TO_MILLI to ANSI/ISO C standard ver. * * Copyright 1999, Atlantic Aerospace Electronics Corp. */ #ifdef USE_GETTIMEOFDAY #include /* for timeval definition */ #include /* for gettimeofday() definition */ #include "errorMessage.h" /* for errorMessage() definition */ #else /* USE_GETTIMEOFDAY undefined */ #include /* for time() definition */ #endif /* USE_GETTIMEOFDAY */ #include /* for assert() */ #include "dataManagement.h" /* for primitive type definitions */ #include "metrics.h" /* for Time type definition */ /* * Static value of program start time * - value is stored as timeval returned by gettimeofday() * - timeval struct represents the time in seconds and microseconds since * Jan 1, 1970. * - don't use structure because difficulty in working with two longs for * statistical calcs and milliseconds will suffice for timing fidelity. */ #ifdef USE_GETTIMEOFDAY static struct timeval startTime; #define MILLION 1000000 #define MILLION_TO_MILLI 1e-3 #define SECONDS_TO_MILLI 1000 #else static time_t startTime; #define SECONDS_TO_MILLI 1000 #endif /* USE_GETTIMEOFDAY */ /* * Name: initTime * Input: none * Output: none * Return: void * Description: Initialize the static startTime variable which will be used * by getTime() to return time in milliseconds since program * start, i.e., when the initTime() routine was called. * Calls: errorMessage() * System: gettimeofday(), or * time() * Author: M.L.Rivas * * Revision History: * * Date Name Revision * ------- --------------- ------------------------------ * 27May99 Matthew Rivas Created * * Copyright 1999, Atlantic Aerospace Electronics Corp. */ void initTime( void ) { /* beginning of initTime() */ #ifdef USE_GETTIMEOFDAY Int error; /* flag for error checking on gettimeofday() */ static Char name[] = "initTime"; #endif /* USE_GETTIMEOFDAY */ #ifdef USE_GETTIMEOFDAY error = gettimeofday( &startTime, NULL ); if ( error == -1 ) { /* check for error */ errorMessage( "system time failure - can't set start time", REPLACE ); errorMessage( name, PREPEND ); flushErrorMessage(); } /* end of if error == -1 */ /* * Check that seconds and microseconds from Jan 1, 1970 are positive, and * that the microseconds value is less than a million, otherwise the * seconds would have been incremented. */ assert( startTime.tv_sec >= 0 && \ startTime.tv_usec >= 0 && \ startTime.tv_usec < MILLION ); #else /* USE_GETTIMEOFDAY undefined */ startTime = time( NULL ); #endif /* USE_GETTIMEOFDAY */ return; } /* end of initTime() */ /* * Name: getTime * Input: none * Output: milliseconds since program start * Return: Time * Description: The routine provides a wrapper for the system timing * routines and returns the current time in milliseconds from * the beginning of program execution, i.e., when initTime() * routine was called. The routine is setup to be compiled * using the gettimeofday() routine or the ANSI/ISO standard * time() routine. * Calls: errorMessage() * System: gettimeofday(), or * difftime() * time() * Author: M.L.Rivas * * Revision History: * * Date Name Revision * ------- --------------- ------------------------------ * 27May99 Matthew Rivas Created * * Copyright 1999, Atlantic Aerospace Electronics Corp. */ Time getTime( void ) { /* beginning of getTime() */ Time currentTime; /* current time in milliseconds */ #ifdef USE_GETTIMEOFDAY Int error; /* flag for checking on gettimeofday() */ struct timeval temp; /* current time returned by gettimeofday() */ static Char name[] = "getTime"; #else /* USE_GETTIMEOFDAY undefined */ time_t temp; /* current time returned by time() */ #endif /* USE_GETTIMEOFDAY */ #ifdef USE_GETTIMEOFDAY /* * Check that seconds and microseconds from Jan 1, 1970 are positive, and * that the microseconds value is less than a million, otherwise the * seconds would have been incremented. */ assert( startTime.tv_sec >= 0 && \ startTime.tv_usec >= 0 && \ startTime.tv_usec < MILLION ); /* * Get the current time and store in temp. Check for error, an if none, * calculate difference in milliseconds between current time and startTime. */ error = gettimeofday( &temp, NULL ); if ( error == -1 ) { /* check for error */ errorMessage( "system time failure - can't get time", REPLACE ); errorMessage( name, PREPEND ); flushErrorMessage(); currentTime = MINIMUM_VALUE_OF_INT; } /* end of if error == -1 */ else { /* * Check that seconds and microseconds from Jan 1, 1970 are positive, * and that the microseconds value is less than a million, otherwise * the seconds would have been incremented. */ assert( temp.tv_sec >= 0 && \ temp.tv_usec >= 0 && \ temp.tv_usec < MILLION ); /* * The current time must be later than the start time for the time * difference arithmetic to work properly. */ assert( temp.tv_sec > startTime.tv_sec || \ ( temp.tv_sec == startTime.tv_sec && \ temp.tv_usec >= startTime.tv_usec ) ); /* * Determine milliseconds conversion of difference between the current * time, temp, and the start time, startTime. Because 0 <= usec < * MILLION and it is assumed that the current time is later than the * start time, only two cases exist for the conversion. The first is * that the current time microseconds are greater than the start time * microseconds. For this case, the current time in milliseconds is * the sum of the seconds difference and the microseconds difference * with the appropriate conversion factors, i.e., SECONDS_TO_MILLI = * 1000 and MILLION_TO_MILLI = 1e-3. The second case is that the * current time microseconds is less than the start time microseconds. * For this case, the current time in milliseconds is the sum of the * seconds difference minus one and the microseconds difference plus a * MILLION with the appropriate conversion factors. Note that the * minus one to the seconds difference and plus a MILLION to the * microseconds, is the carry, i.e., a second was taken from the * seconds place and added to the microseconds place. */ if ( temp.tv_usec >= startTime.tv_usec ) { currentTime = SECONDS_TO_MILLI * ( temp.tv_sec - startTime.tv_sec ); currentTime += MILLION_TO_MILLI * ( temp.tv_usec - startTime.tv_usec ); } /* end of temp.usec >= start.usec */ else { currentTime = SECONDS_TO_MILLI * ( temp.tv_sec - startTime.tv_sec - 1 ); currentTime += MILLION_TO_MILLI * ( temp.tv_usec - startTime.tv_usec + MILLION ); } /* end of temp.usec < start.usec */ /* * Check for overflow of negative time difference, both of which should * never happen since the system call should ensure non-negative * differences and the maximum value for a time difference using * milliseconds is 49.71 days. */ if ( currentTime > MAXIMUM_VALUE_OF_INT ) { errorMessage( "overflow error calculating current time", REPLACE ); errorMessage( name, PREPEND ); flushErrorMessage(); currentTime = MAXIMUM_VALUE_OF_INT; } /* end of upper bound check on currentTime */ else if ( currentTime < 0 ) { errorMessage( "start time appears not to be set", REPLACE ); errorMessage( name, PREPEND ); flushErrorMessage(); currentTime = 0; } /* end of lower bound check on currentTime */ } /* end of if error != -1 */ #else /* USE_GETTIMEOFDAY undefined */ /* * Get the current time, determine the difference in seconds since * the start time, convert seconds to milliseconds, and set current * time to correct value. */ temp = time( NULL ); currentTime = SECONDS_TO_MILLI * (Int)difftime( temp, startTime ); #endif /* USE_GETTIMEOFDAY */ return ( currentTime ); } /* end of getTime() */