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

File:

• libcfa/src/clock.hfa (modified) (8 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 : Wed Apr 14 17:48:25 2021
+// Update Count     : 20
 //
 
@@ -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 reset( Clock & clk, Duration adj ) with( clk ) {
                 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
+        void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); }
+        void ?{}( Clock & clk, Duration adj ) { reset( 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 resolutionNsec() {
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME, &res );
                 return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-        } // resolutionHi
+        } // resolutionNsec
 
-        Duration resolution() {                                                         // clock resolution without nanoseconds (coarse)
+        Duration resolution() {
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME_COARSE, &res );
@@ -55 +54 @@
         } // resolution
 
-        Time timeHiRes() {                                                                      // real time with nanoseconds
+        Time timeNsec() {                                                                       // with nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME, &curr );
                 return (Time){ curr };
-        } // timeHiRes
+        } // timeNsec
 
-        Time time() {                                                                           // real time without nanoseconds
+        Time time() {                                                                           // without nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME_COARSE, &curr );
@@ -68 +67 @@
         } // time
 
-        Time time( Clock & clk ) with( clk ) {                          // real time for given clock
+        Time time( Clock & clk ) with( clk ) {
                 return time() + offset;
         } // time
@@ -76 +75 @@
         } // ?()
 
-        timeval time( Clock & clk ) {                                           // convert to C time format
+        timeval time( Clock & clk ) {
                 return (timeval){ clk() };
         } // time
@@ -89 +88 @@
         // 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
+        Duration processor() {
                 timespec ts;
                 clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
@@ -98 +97 @@
         // 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
+        Duration program() {
                 timespec ts;
                 clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
@@ -104 +103 @@
         } // 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
+        // Monotonic stopwatch starting at machine boot and includes 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() {
                 timespec ts;
                 clock_gettime( CLOCK_BOOTTIME, &ts );