Timing.h

Go to the documentation of this file.

#ifndef SimTK_SimTKCOMMON_TIMING_H_
#define SimTK_SimTKCOMMON_TIMING_H_

/* -------------------------------------------------------------------------- *
 *                      SimTK Core: SimTK Simbody(tm)                         *
 * -------------------------------------------------------------------------- *
 * This is part of the SimTK Core biosimulation toolkit originating from      *
 * Simbios, the NIH National Center for Physics-Based Simulation of           *
 * Biological Structures at Stanford, funded under the NIH Roadmap for        *
 * Medical Research, grant U54 GM072970. See https://simtk.org.               *
 *                                                                            *
 * Portions copyright (c) 2010 Stanford University and the Authors.           *
 * Authors: Peter Eastman                                                     *
 * Contributors:                                                              *
 *                                                                            *
 * Permission is hereby granted, free of charge, to any person obtaining a    *
 * copy of this software and associated documentation files (the "Software"), *
 * to deal in the Software without restriction, including without limitation  *
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,   *
 * and/or sell copies of the Software, and to permit persons to whom the      *
 * Software is furnished to do so, subject to the following conditions:       *
 *                                                                            *
 * The above copyright notice and this permission notice shall be included in *
 * all copies or substantial portions of the Software.                        *
 *                                                                            *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,   *
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL    *
 * THE AUTHORS, CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,    *
 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR      *
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE  *
 * USE OR OTHER DEALINGS IN THE SOFTWARE.                                     *
 * -------------------------------------------------------------------------- */

#include "SimTKcommon/internal/common.h"
#include "SimTKcommon/Constants.h"

// This header is needed on Mac and Linux for some or all of the Posix time 
// functions and the timespec struct. We include it on Windows also for 
// uniform cross-platform behavior, since there are many other useful time-
// date-handling symbols declared here on all platforms.
#include <ctime>

#if defined(_MSC_VER)
    /* On Windows, the timespec struct is not defined. However, note that the 
    timespec struct is also defined in the pthread.h header on Windows, so the 
    guard symbols must match here to avoid a duplicate declaration. */
    #ifndef HAVE_STRUCT_TIMESPEC
    #define HAVE_STRUCT_TIMESPEC 1
    struct timespec {
            long tv_sec;  // TODO: this should be time_t but must fix in pthreads too
            long tv_nsec;
    };
    #endif /* HAVE_STRUCT_TIMESPEC */

    /* Posix nanosleep() sleeps the indicated number of nanoseconds and returns
    0, or if it is interrupted early it returns how much time was left in 
    rem and returns EINTR. Ours is not interruptable so will always succeed and
    return rem==0. It is OK if rem is NULL, but req==NULL or req<0 returns 
    EINVAL. A time of req==0 is allowed and our interpretation is that the 
    thread relinquishes its time slice to another ready-to-run thread if there
    is one, otherwise returns immediately. This implementation rounds the 
    desired sleep time to the nearest millisecond. On a Linux system, this 
    requires including <time.h> (or <ctime>), which we already included 
    above. */
    SimTK_SimTKCOMMON_EXPORT int nanosleep(const struct timespec* req, struct timespec* rem);

    /* Posix declares this handy function obsolete, but I don't think it is in
    any danger of going away. It sleeps for the given number of microseconds.
    However, using SimTK::sleepInNs() or SimTK::sleepInSec() is safer. */
    typedef unsigned int useconds_t;
    inline int usleep(useconds_t us) {
        struct timespec req;
        req.tv_sec  = (long) (us / 1000000U);
        req.tv_nsec = (long)((us % 1000000U)*1000U);
        int status = nanosleep(&req,0);
        return status ? -1 : 0;
    }
#endif

#if defined(_MSC_VER) || defined(__APPLE__)
    // On Windows and OSX, the Posix clock_gettime function is missing.
    typedef long clockid_t;

    /* These constants are the clock ids we support. All the varieties of 
    CLOCK_MONOTONIC are high resolution with no NTP adjustments. I measured 
    the resolutions on a single Windows 7 machine; hopefully they are typical
    (resolution here means how often they are updated):
      - MONOTONIC (counter):    0.001ms      1us
      - REALTIME (time of day):    1ms    1000us
      - CPUTIME (either):         20ms   20000us
    These are slightly conservative resolutions so you should be able to 
    achieve them in practice. */
    #define CLOCK_REALTIME           1 // time of day clock, from 1/1/1970
    #define CLOCK_MONOTONIC          2 // counter from last boot time
    #define CLOCK_MONOTONIC_HR       3 // "high resolution" (same)
    #define CLOCK_MONOTONIC_RAW      4 // "not subject to NTP adjustments" (same)
    #define CLOCK_THREAD_CPUTIME_ID  5 // current thread's cpu time (kernel+user)
    #define CLOCK_PROCESS_CPUTIME_ID 6 // cumulative cpu time of all threads of
                                       //   this process, live or dead

    /* Returns zero if it succeeds (or if tp==NULL); otherwise EINVAL. On a 
    Linux system, this requires including <time.h> (or <ctime>) and linking 
    with -lrt to get the realtime library. */
    SimTK_SimTKCOMMON_EXPORT int clock_gettime(clockid_t clock_id, 
                                               struct timespec *tp); 
#endif



namespace SimTK {

inline long long timespecToNs(const timespec& ts)
{   return (long long)ts.tv_sec*1000000000LL + (long long)ts.tv_nsec; }

inline void nsToTimespec(const long long& ns, timespec& ts) 
{   ts.tv_sec  = (long)(ns / 1000000000LL); // signed
    if (ns >= 0) ts.tv_nsec =  (long)(  ns  % 1000000000LL);
    else         ts.tv_nsec = -(long)((-ns) % 1000000000LL); }

inline double nsToSec(const long long& ns) 
{   return (double)(ns*SimTK_NS_TO_S); }

inline long long secToNs(const double& s) 
{   return (long long)(s*SimTK_S_TO_NS); }
inline double cpuTime() 
{   timespec ts;
    clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts);
    return (double)(timespecToNs(ts)*SimTK_NS_TO_S); }

inline double threadCpuTime() 
{   timespec ts;
    clock_gettime(CLOCK_THREAD_CPUTIME_ID, &ts);
    return (double)(timespecToNs(ts)*SimTK_NS_TO_S); }
inline long long realTimeInNs() {
    timespec ts;
    #ifdef CLOCK_MONOTONIC_RAW
        clock_gettime(CLOCK_MONOTONIC_RAW, &ts);
    #else
        clock_gettime(CLOCK_MONOTONIC, &ts);
    #endif
    return timespecToNs(ts);
}

inline double realTime() {return nsToSec(realTimeInNs());}

inline void sleepInNs(const long long& ns) 
{   timespec ts;
    nsToTimespec(ns, ts);
    nanosleep(&ts, 0); }

inline void sleepInSec(const double& seconds) {sleepInNs(secToNs(seconds));}
} // namespace SimTK

#endif // SimTK_SimTKCOMMON_TIMING_H_