source: libcfa/src/clock.hfa @ 6d8e1ab

//
// Cforall Version 1.0.0 Copyright (C) 2018 University of Waterloo
//
// The contents of this file are covered under the licence agreement in the
// file "LICENCE" distributed with Cforall.
//
// clock --
//
// Author           : Peter A. Buhr
// Created On       : Thu Apr 12 14:36:06 2018
// Last Modified By : Peter A. Buhr
// Last Modified On : Sun Apr 18 08:12:16 2021
// Update Count     : 28
//

#include <time.hfa>

//######################### C time #########################

static inline char * ctime( time_t tp ) { char * buf = ctime( &tp ); buf[24] = '\0'; return buf; }
static inline char * ctime_r( time_t tp, char * buf ) { ctime_r( &tp, buf ); buf[24] = '\0'; return buf; }
static inline tm * gmtime( time_t tp ) { return gmtime( &tp ); }
static inline tm * gmtime_r( time_t tp, tm * result ) { return gmtime_r( &tp, result ); }
static inline tm * localtime( time_t tp ) { return localtime( &tp ); }
static inline tm * localtime_r( time_t tp, tm * result ) { return localtime_r( &tp, result ); }

//######################### Clock #########################

struct Clock {                                                                                  // virtual clock
        // private
        Duration offset;                                                                        // offset from computer real-time
};

static inline {
        void reset( Clock & clk, Duration adj ) with( clk ) { // change offset
                offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
        } // reset

        void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); } // create no offset
        void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); } // create with offset

        // System-wide clock that measures real, i.e., wall-clock) time. This clock is affected by discontinuous jumps in
        // the system time. For example, manual changes of the clock, and incremental adjustments performed by adjtime(3)
        // and NTP (daylight saving (Fall back).
        Duration resolutionHi() {                                                       // clock resolution in nanoseconds (fine)
                struct timespec res;
                clock_getres( CLOCK_REALTIME, &res );
                return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
        } // resolutionHi

        Duration resolution() {                                                         // clock resolution without nanoseconds (coarse)
                struct timespec res;
                clock_getres( CLOCK_REALTIME_COARSE, &res );
                return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
        } // resolution

        Time timeHiRes() {                                                                      // real time with nanoseconds
                timespec curr;
                clock_gettime( CLOCK_REALTIME, &curr );
                return (Time){ curr };
        } // timeHiRes

        Time time() {                                                                           // real time without nanoseconds
                timespec curr;
                clock_gettime( CLOCK_REALTIME_COARSE, &curr );
                curr.tv_nsec = 0;
                return (Time){ curr };
        } // time

        Time time( Clock & clk ) with( clk ) {                          // real time for given clock
                return time() + offset;
        } // time

        Time ?()( Clock & clk ) with( clk ) {                           // alternative syntax
                return time() + offset;
        } // ?()

        timeval time( Clock & clk ) {                                           // convert to C time format
                return (timeval){ clk() };
        } // time

        tm time( Clock & clk ) with( clk ) {
                tm ret;
                localtime_r( time( clk ).tv_sec, &ret );
                return ret;
        } // time

        // CFA processor CPU-time watch that ticks when the processor (kernel thread) is running. This watch is affected by
        // discontinuous jumps when the OS is not running the kernal thread. A duration is returned because the value is
        // relative and cannot be converted to real-time (wall-clock) time.
        Duration processor() {                                                          // non-monotonic duration of kernel thread
                timespec ts;
                clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
                return (Duration){ ts };
        } // processor

        // Program CPU-time watch measures CPU time consumed by all processors (kernel threads) in the UNIX process.  This
        // watch is affected by discontinuous jumps when the OS is not running the kernel threads. A duration is returned
        // because the value is relative and cannot be converted to real-time (wall-clock) time.
        Duration program() {                                                            // non-monotonic duration of program CPU
                timespec ts;
                clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
                return (Duration){ ts };
        } // program

        // Monotonic duration from machine boot and including system suspension. This watch is unaffected by discontinuous
        // jumps resulting from manual changes of the clock, and incremental adjustments performed by adjtime(3) and NTP
        // (Fall back). A duration is returned because the value is relative and cannot be converted to real-time
        // (wall-clock) time.
        Duration boot() {                                                                       // monotonic duration since computer boot
                timespec ts;
                clock_gettime( CLOCK_BOOTTIME, &ts );
                return (Duration){ ts };
        } // boot
} // distribution

// Local Variables: //
// mode: c //
// tab-width: 4 //
// End: //