coTimer.h

Go to the documentation of this file.

/* This file is part of COVISE.
 
   You can use it under the terms of the GNU Lesser General Public License
   version 2.1 or later, see lgpl-2.1.txt.
 
 * License: LGPL 2+ */
 
#ifndef _TIMER_H_
#define _TIMER_H_
 
#ifdef _MSC_VER
#include <sys/timeb.h>
#else
#include <sys/time.h>
#endif
#include "coSignal.h"
 
#include <iostream>
#include <cstdlib>
#include <cstring>
 
// define different time measurement methods
#if defined(__sgi)
#define POSIX_TIME
//#define CLOCK_ID      CLOCK_SGI_CYCLE
#define CLOCK_ID CLOCK_REALTIME
#endif
 
namespace covise
{
 
// +++++++ POSIX time-calls
#if defined(POSIX_TIME)
typedef struct timespec TimeType;
 
// this is a macro to save time (inlined by Preprocesor)
#define TIME_CALL(x) clock_gettime(CLOCK_ID, x)
 
inline void TIME_SET(TimeType &x, double ti)
{
    x.tv_sec = (long)(ti);
    x.tv_nsec = (long)((ti - x.tv_sec) * 1.0e9);
}
 
inline double coTimerGetFloat(const TimeType &x)
{
    return (double)x.tv_sec + 1.0e-9 * x.tv_nsec;
}
 
// +++++++ SysV time-calls
#else
#ifdef _MSC_VER
 
typedef struct __timeb64 TimeType;
#define TIME_CALL(x) \
    {                \
        _ftime64(x); \
    }
 
inline void TIME_SET(TimeType &x, double ti)
{
    x.time = (long)(ti);
    x.millitm = (unsigned short)((ti - x.time) * 1.0e6f);
}
 
inline double coTimerGetFloat(const TimeType &x)
{
    return x.time + 1e-6 * x.millitm;
}
 
#else
typedef struct timeval TimeType;
#define TIME_CALL(x) gettimeofday(x, NULL)
 
inline void TIME_SET(TimeType &x, double ti)
{
    x.tv_sec = (long)(ti);
    x.tv_usec = (long)((ti - x.tv_sec) * 1.0e6);
}
 
inline double coTimerGetFloat(const TimeType &x)
{
    return x.tv_sec + 1e-6 * x.tv_usec;
}
#endif
#endif
 
#ifndef CREATE_TIMEBASE_PROG
 
#ifdef NO_TIMER
#else
#define MARK0(text)          \
    {                        \
        coTimer::mark(text); \
    }
#define MARK1(mask, d1)                       \
    {                                         \
        sprintf(coTimer::mark(), mask, (d1)); \
    }
#define MARK2(mask, d1, d2)                         \
    {                                               \
        sprintf(coTimer::mark(), mask, (d1), (d2)); \
    }
#define MARK3(mask, d1, d2, d3)                           \
    {                                                     \
        sprintf(coTimer::mark(), mask, (d1), (d2), (d3)); \
    }
 
#define MARK4(mask, d1, d2, d3, d4)                             \
    {                                                           \
        sprintf(coTimer::mark(), mask, (d1), (d2), (d3), (d4)); \
    }
 
#define MARK5(mask, d1, d2, d3, d4, d5)                               \
    {                                                                 \
        sprintf(coTimer::mark(), mask, (d1), (d2), (d3), (d4), (d5)); \
    }
 
#define MARK6(mask, d1, d2, d3, d4, d5, d6)                                 \
    {                                                                       \
        sprintf(coTimer::mark(), mask, (d1), (d2), (d3), (d4), (d5), (d6)); \
    }
#endif
 
class UTILEXPORT coTimer : public coSignalHandler
{
private:
    enum
    {
        MAX_LEN = 128
    };
 
    int maxElem, actElem;
    char *descField;
    TimeType *timeField, *actTval, startTime;
    std::ofstream *stream;
 
    static coTimer *s_timerObj;
    static char s_buffer[MAX_LEN];
 
    virtual void sigHandler(int sigNo);
    virtual const char *sigHandlerName()
    {
        return "coTimer";
    }
 
protected:
    coTimer(const char *fileNameBase, int length, bool handleSignals);
 
    char *int_mark()
    {
#ifndef NOTIMER
        if (actElem >= maxElem)
            flush();
        actTval++;
        actElem++;
        TIME_CALL(actTval);
        return descField + MAX_LEN * actElem;
#else
        static char dummy[MAX_LEN] return dummy;
#endif
    }
 
#ifndef NOTIMER
    void int_mark(const char *string)
    {
        if (actElem >= maxElem)
            flush();
        actTval++;
        actElem++;
        TIME_CALL(actTval);
        strcpy(descField + MAX_LEN * actElem, string);
    }
#else
    void mark(const char *)
    {
    }
#endif
 
    void flush();
 
public:
    virtual ~coTimer();
 
    static void init(const char *fileNameBase, int length, bool handleSignals = true);
    static void quit();
 
    static char *mark()
    {
        char *res;
        if (s_timerObj)
            res = s_timerObj->int_mark();
        else
            res = s_buffer;
        return res;
    }
 
    static void mark(const char *string)
    {
        if (s_timerObj)
            s_timerObj->int_mark(string);
    }
};
#endif // getTimeBase
}
#endif