Changes in libcfa/src/clock.hfa [6645cda: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 : Wed Apr 14 17:48:25 2021
-// Update Count     : 20
+// Last Modified On : Mon Jan  6 12:49:58 2020
+// Update Count     : 9
 //
 
@@ -32 +32 @@
 
 static inline {
-        void reset( Clock & clk, Duration adj ) with( clk ) {
+        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 } ); }
-        void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); }
+        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 resolutionNsec() {
+        Duration getResNsec() {
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME, &res );
                 return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-        } // resolutionNsec
+        } // getRes
 
-        Duration resolution() {
+        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 timeNsec() {                                                                       // with nanoseconds
+        Time getTimeNsec() {                                                            // with nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME, &curr );
                 return (Time){ curr };
-        } // timeNsec
+        } // getTimeNsec
 
-        Time 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 ) {
-                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 ) {
+        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() {
+        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() {
-                timespec ts;
-                clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
-                return (Duration){ ts };
-        } // program
-
-        // 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 );
-                return (Duration){ ts };
-        } // boot
+                return (Time){ ts };
+    } // getCPUTime
 } // distribution