Changeset 5407cdc for libcfa/src/clock.hfa

Timestamp:

Apr 28, 2021, 4:56:50 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

8d66610

Parents:

feacef9 (diff), b7fd2db6 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

• libcfa/src/clock.hfa (modified) (2 diffs)

libcfa/src/clock.hfa

@@ -10 +10 @@
 // Created On       : Thu Apr 12 14:36:06 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jan  6 12:49:58 2020
-// Update Count     : 9
+// Last Modified On : Sun Apr 18 08:12:16 2021
+// Update Count     : 28
 //
 
@@ -27 +27 @@
 //######################### Clock #########################
 
-struct Clock {                                                                                  // private
-        Duration offset;                                                                        // for virtual clock: contains offset from real-time
+struct Clock {                                                                                  // virtual clock
+        // private
+        Duration offset;                                                                        // offset from computer real-time
 };
 
 static inline {
-        void resetClock( Clock & clk, Duration adj ) with( clk ) {
+        void reset( Clock & clk, Duration adj ) with( clk ) { // change offset
                 offset = adj + __timezone`s;                                    // timezone (global) is (UTC - local time) in seconds
-        } // resetClock
+        } // reset
 
-        void ?{}( Clock & clk, Duration adj ) { resetClock( clk, adj ); }
+        void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); } // create no offset
+        void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); } // create with offset
 
-        Duration getResNsec() {
+        // 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;
-        } // getRes
+        } // resolutionHi
 
-        Duration getRes() {
+        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;
-        } // getRes
+        } // resolution
 
-        Time getTimeNsec() {                                                            // with nanoseconds
+        Time timeHiRes() {                                                                      // real time with nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME, &curr );
                 return (Time){ curr };
-        } // getTimeNsec
+        } // timeHiRes
 
-        Time getTime() {                                                                        // without nanoseconds
+        Time time() {                                                                           // real time without nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME_COARSE, &curr );
                 curr.tv_nsec = 0;
                 return (Time){ curr };
-        } // getTime
+        } // time
 
-        Time getTime( Clock & clk ) with( clk ) {
-                return getTime() + offset;
-        } // getTime
+        Time time( Clock & clk ) with( clk ) {                          // real time for given clock
+                return time() + offset;
+        } // time
 
         Time ?()( Clock & clk ) with( clk ) {                           // alternative syntax
-                return getTime() + offset;
-        } // getTime
+                return time() + offset;
+        } // ?()
 
-        timeval getTime( Clock & clk ) {
+        timeval time( Clock & clk ) {                                           // convert to C time format
                 return (timeval){ clk() };
-        } // getTime
+        } // time
 
-        tm getTime( Clock & clk ) with( clk ) {
+        tm time( Clock & clk ) with( clk ) {
                 tm ret;
-                localtime_r( getTime( clk ).tv_sec, &ret );
+                localtime_r( time( clk ).tv_sec, &ret );
                 return ret;
-        } // getTime
+        } // time
 
-        Time getCPUTime() {
+        // 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 (Time){ ts };
-    } // getCPUTime
+                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