
/*
 *  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 <sys/time.h>       /* for timeval definition           */
#include <unistd.h>         /* for gettimeofday() definition    */
#include "errorMessage.h"   /* for errorMessage() definition    */
#else  /* USE_GETTIMEOFDAY undefined */
#include <time.h>           /* for time() definition            */
#endif /* USE_GETTIMEOFDAY */

#include <assert.h>         /* 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()        */