Changeset a4b0aa4

Timestamp:

Apr 15, 2021, 11:45:52 AM (4 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:

8cfa4ef

Parents:

a017ee7 (diff), 9344f0e (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

Location:

libcfa/src

Files:

• clock.hfa (modified) (2 diffs)
• time.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 : Wed Apr 14 17:48:25 2021
+// Update Count     : 20
 //
 
@@ -32 +32 @@
 
 static inline {
-        void resetClock( Clock & clk, Duration adj ) with( clk ) {
+        void reset( Clock & clk, Duration adj ) with( clk ) {
                 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 } ); }
+        void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); }
 
-        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 resolutionNsec() {
                 struct timespec res;
                 clock_getres( CLOCK_REALTIME, &res );
                 return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-        } // getRes
+        } // resolutionNsec
 
-        Duration getRes() {
+        Duration resolution() {
                 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 timeNsec() {                                                                       // with nanoseconds
                 timespec curr;
                 clock_gettime( CLOCK_REALTIME, &curr );
                 return (Time){ curr };
-        } // getTimeNsec
+        } // timeNsec
 
-        Time getTime() {                                                                        // without nanoseconds
+        Time 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 ) {
+                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 ) {
                 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() {
                 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() {
+                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
 } // distribution
 

libcfa/src/time.hfa

@@ -10 +10 @@
 // Created On       : Wed Mar 14 23:18:57 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun 17 16:13:00 2020
-// Update Count     : 663
+// Last Modified On : Wed Apr 14 09:30:30 2021
+// Update Count     : 664
 //
 
@@ -29 +29 @@
 static inline {
         Duration ?=?( Duration & dur, __attribute__((unused)) zero_t ) { return dur{ 0 }; }
+
+        void ?{}( Duration & dur, timeval t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * 1000; }
+        Duration ?=?( Duration & dur, timeval t ) with( dur ) {
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_usec * (TIMEGRAN / 1_000_000LL);
+                return dur;
+        } // ?=?
+
+        void ?{}( Duration & dur, timespec t ) with( dur ) { tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec; }
+        Duration ?=?( Duration & dur, timespec t ) with( dur ) {
+                tn = (int64_t)t.tv_sec * TIMEGRAN + t.tv_nsec;
+                return dur;
+        } // ?=?
 
         Duration +?( Duration rhs ) with( rhs ) { return (Duration)@{ +tn }; }