Changes in libcfa/src/clock.hfa [4aa495f:4834563]

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