Index: libcfa/src/clock.hfa
===================================================================
--- libcfa/src/clock.hfa	(revision a017ee7e5c430fc297274eb5bf2b1e7a1e81c6ad)
+++ libcfa/src/clock.hfa	(revision a4b0aa4a6cf35811daa6308b31485b0648fc84e4)
@@ -10,6 +10,6 @@
 // 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,58 +32,84 @@
 
 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
 
Index: libcfa/src/time.hfa
===================================================================
--- libcfa/src/time.hfa	(revision a017ee7e5c430fc297274eb5bf2b1e7a1e81c6ad)
+++ libcfa/src/time.hfa	(revision a4b0aa4a6cf35811daa6308b31485b0648fc84e4)
@@ -10,6 +10,6 @@
 // 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,4 +29,16 @@
 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 }; }