Index: benchmark/benchcltr.hfa
===================================================================
--- benchmark/benchcltr.hfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/benchcltr.hfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -114,5 +114,5 @@
 	for() {
 		sleep(100`ms);
-		end = timeNsec();
+		end = timeHiRes();
 		Duration delta = end - start;
 		/*if(is_tty)*/ {
@@ -126,5 +126,5 @@
 }
 #else
-uint64_t timeNsec() {
+uint64_t timeHiRes() {
 	timespec curr;
 	clock_gettime( CLOCK_REALTIME, &curr );
@@ -140,5 +140,5 @@
 	for(;;) {
 		usleep(100000);
-		end = timeNsec();
+		end = timeHiRes();
 		uint64_t delta = end - start;
 		/*if(is_tty)*/ {
Index: benchmark/io/http/protocol.cfa
===================================================================
--- benchmark/io/http/protocol.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/io/http/protocol.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -249,5 +249,5 @@
 
 		char buff[100];
-		Time now = timeNsec();
+		Time now = timeHiRes();
 		strftime( buff, 100, "%a, %d %b %Y %H:%M:%S %Z", now );
 		sout | "Updated date to '" | buff | "'";
Index: benchmark/io/readv-posix.c
===================================================================
--- benchmark/io/readv-posix.c	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/io/readv-posix.c	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -111,5 +111,5 @@
 				printf("Starting\n");
 				bool is_tty = isatty(STDOUT_FILENO);
-				start = timeNsec();
+				start = timeHiRes();
 				run = true;
 
@@ -118,5 +118,5 @@
 
 				run = false;
-				end = timeNsec();
+				end = timeHiRes();
 				printf("\nDone\n");
 
Index: benchmark/io/readv.cfa
===================================================================
--- benchmark/io/readv.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/io/readv.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -147,5 +147,5 @@
 				printf("Starting\n");
 				bool is_tty = isatty(STDOUT_FILENO);
-				start = timeNsec();
+				start = timeHiRes();
 				run = true;
 
@@ -156,5 +156,5 @@
 
 				run = false;
-				end = timeNsec();
+				end = timeHiRes();
 				printf("\nDone\n");
 			}
Index: benchmark/readyQ/cycle.cc
===================================================================
--- benchmark/readyQ/cycle.cc	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/cycle.cc	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -89,5 +89,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(int i = 0; i < nthreads; i++) {
@@ -97,5 +97,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/cycle.cfa
===================================================================
--- benchmark/readyQ/cycle.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/cycle.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -65,5 +65,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(i; nthreads) {
@@ -73,5 +73,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/cycle.cpp
===================================================================
--- benchmark/readyQ/cycle.cpp	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/cycle.cpp	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -93,5 +93,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(int i = 0; i < nthreads; i++) {
@@ -101,5 +101,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/locality.cc
===================================================================
--- benchmark/readyQ/locality.cc	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/locality.cc	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -281,5 +281,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(size_t i = 0; i < nthreads; i++) {
@@ -289,5 +289,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/locality.cfa
===================================================================
--- benchmark/readyQ/locality.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/locality.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -232,5 +232,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(i; nthreads) {
@@ -240,5 +240,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/locality.cpp
===================================================================
--- benchmark/readyQ/locality.cpp	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/locality.cpp	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -287,5 +287,5 @@
 
 			bool is_tty = isatty(STDOUT_FILENO);
-			start = timeNsec();
+			start = timeHiRes();
 
 			for(size_t i = 0; i < nthreads; i++) {
@@ -295,5 +295,5 @@
 
 			stop = true;
-			end = timeNsec();
+			end = timeHiRes();
 			printf("\nDone\n");
 
Index: benchmark/readyQ/rq_bench.hfa
===================================================================
--- benchmark/readyQ/rq_bench.hfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/rq_bench.hfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -73,5 +73,5 @@
 	for() {
 		sleep(100`ms);
-		Time end = timeNsec();
+		Time end = timeHiRes();
 		Duration delta = end - start;
 		if(is_tty) {
Index: benchmark/readyQ/rq_bench.hpp
===================================================================
--- benchmark/readyQ/rq_bench.hpp	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/rq_bench.hpp	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -46,5 +46,5 @@
 	}
 
-uint64_t timeNsec() {
+uint64_t timeHiRes() {
 	timespec curr;
 	clock_gettime( CLOCK_REALTIME, &curr );
@@ -60,5 +60,5 @@
 	for(;;) {
 		Sleeper::usleep(100000);
-		uint64_t end = timeNsec();
+		uint64_t end = timeHiRes();
 		uint64_t delta = end - start;
 		if(is_tty) {
Index: benchmark/readyQ/yield.cfa
===================================================================
--- benchmark/readyQ/yield.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ benchmark/readyQ/yield.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -66,5 +66,5 @@
 
 				bool is_tty = isatty(STDOUT_FILENO);
-				start = timeNsec();
+				start = timeHiRes();
 				run = true;
 
@@ -75,5 +75,5 @@
 
 				run = false;
-				end = timeNsec();
+				end = timeHiRes();
 				printf("\nDone\n");
 			}
Index: example/io/batch-readv.c
===================================================================
--- example/io/batch-readv.c	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ example/io/batch-readv.c	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -66,5 +66,5 @@
 }
 
-uint64_t getTimeNsec() {
+uint64_t timeHiRes() {
 	timespec curr;
 	clock_gettime( CLOCK_REALTIME, &curr );
@@ -163,10 +163,10 @@
 
 	printf("Running for %f second, reading %d bytes in batches of %d\n", duration, buflen, batch);
-	uint64_t start = getTimeNsec();
-	uint64_t end   = getTimeNsec();
-	uint64_t prev  = getTimeNsec();
+	uint64_t start = timeHiRes();
+	uint64_t end   = timeHiRes();
+	uint64_t prev  = timeHiRes();
 	for(;;) {
 		submit_and_drain(&iov, batch);
-		end = getTimeNsec();
+		end = timeHiRes();
 		uint64_t delta = end - start;
 		if( to_fseconds(end - prev) > 0.1 ) {
Index: libcfa/src/clock.hfa
===================================================================
--- libcfa/src/clock.hfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ libcfa/src/clock.hfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -10,6 +10,6 @@
 // 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 : Sun Apr 18 08:12:16 2021
+// Update Count     : 28
 //
 
@@ -27,26 +27,27 @@
 //######################### Clock #########################
 
-struct Clock {											// private
-	Duration offset;									// for virtual clock: contains offset from real-time
+struct Clock {											// virtual clock
+	// private
+	Duration offset;									// offset from computer real-time
 };
 
 static inline {
-	void reset( Clock & clk, Duration adj ) with( clk ) {
+	void reset( Clock & clk, Duration adj ) with( clk ) { // change offset
 		offset = adj + __timezone`s;					// timezone (global) is (UTC - local time) in seconds
 	} // reset
 
-	void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); }
-	void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); }
+	void ?{}( Clock & clk ) { reset( clk, (Duration){ 0 } ); } // create no offset
+	void ?{}( Clock & clk, Duration adj ) { reset( clk, adj ); } // create with offset
 
 	// 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 resolutionHi() {							// clock resolution in nanoseconds (fine)
 		struct timespec res;
 		clock_getres( CLOCK_REALTIME, &res );
 		return ((int64_t)res.tv_sec * TIMEGRAN + res.tv_nsec)`ns;
-	} // resolutionNsec
+	} // resolutionHi
 
-	Duration resolution() {
+	Duration resolution() {								// clock resolution without nanoseconds (coarse)
 		struct timespec res;
 		clock_getres( CLOCK_REALTIME_COARSE, &res );
@@ -54,11 +55,11 @@
 	} // resolution
 
-	Time timeNsec() {									// with nanoseconds
+	Time timeHiRes() {									// real time with nanoseconds
 		timespec curr;
 		clock_gettime( CLOCK_REALTIME, &curr );
 		return (Time){ curr };
-	} // timeNsec
+	} // timeHiRes
 
-	Time time() {										// without nanoseconds
+	Time time() {										// real time without nanoseconds
 		timespec curr;
 		clock_gettime( CLOCK_REALTIME_COARSE, &curr );
@@ -67,5 +68,5 @@
 	} // time
 
-	Time time( Clock & clk ) with( clk ) {
+	Time time( Clock & clk ) with( clk ) {				// real time for given clock
 		return time() + offset;
 	} // time
@@ -75,5 +76,5 @@
 	} // ?()
 
-	timeval time( Clock & clk ) {
+	timeval time( Clock & clk ) {						// convert to C time format
 		return (timeval){ clk() };
 	} // time
@@ -88,5 +89,5 @@
 	// 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() {
+	Duration processor() {								// non-monotonic duration of kernel thread
 		timespec ts;
 		clock_gettime( CLOCK_THREAD_CPUTIME_ID, &ts );
@@ -97,5 +98,5 @@
 	// 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() {
+	Duration program() {								// non-monotonic duration of program CPU
 		timespec ts;
 		clock_gettime( CLOCK_PROCESS_CPUTIME_ID, &ts );
@@ -103,9 +104,9 @@
 	} // 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() {
+	// 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 );
Index: libcfa/src/concurrency/ready_queue.cfa
===================================================================
--- libcfa/src/concurrency/ready_queue.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ libcfa/src/concurrency/ready_queue.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -35,4 +35,10 @@
 static const size_t cache_line_size = 64;
 
+#if !defined(__CFA_NO_STATISTICS__)
+	#define __STATS(...) __VA_ARGS__
+#else
+	#define __STATS(...)
+#endif
+
 // No overriden function, no environment variable, no define
 // fall back to a magic number
@@ -52,8 +58,8 @@
 #endif
 
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats));
+static inline struct $thread * search(struct cluster * cltr);
 static inline [unsigned, bool] idx_from_r(unsigned r, unsigned preferred);
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w);
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j);
-static inline struct $thread * search(struct cluster * cltr);
 
 
@@ -269,12 +275,7 @@
 
 			#if !defined(__CFA_NO_STATISTICS__)
-				if(external) {
-					if(local) __atomic_fetch_add(&cltr->stats->ready.pick.ext.local, 1, __ATOMIC_RELAXED);
-					__atomic_fetch_add(&cltr->stats->ready.pick.ext.attempt, 1, __ATOMIC_RELAXED);
-				}
-				else {
-					if(local) __tls_stats()->ready.pick.push.local++;
-					__tls_stats()->ready.pick.push.attempt++;
-				}
+				if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.attempt, 1, __ATOMIC_RELAXED);
+				else if(local) __tls_stats()->ready.push.local.attempt++;
+				else __tls_stats()->ready.push.share.attempt++;
 			#endif
 
@@ -302,12 +303,7 @@
 		// Update statistics
 		#if !defined(__CFA_NO_STATISTICS__)
-			if(external) {
-				if(local) __atomic_fetch_add(&cltr->stats->ready.pick.ext.lsuccess, 1, __ATOMIC_RELAXED);
-				__atomic_fetch_add(&cltr->stats->ready.pick.ext.success, 1, __ATOMIC_RELAXED);
-			}
-			else {
-				if(local) __tls_stats()->ready.pick.push.lsuccess++;
-				__tls_stats()->ready.pick.push.success++;
-			}
+			if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.success, 1, __ATOMIC_RELAXED);
+			else if(local) __tls_stats()->ready.push.local.success++;
+			else __tls_stats()->ready.push.share.success++;
 		#endif
 	}
@@ -334,19 +330,10 @@
 			[j, localj] = idx_from_r(rj, preferred);
 
-			#if !defined(__CFA_NO_STATISTICS__)
-				if(locali && localj) {
-					__tls_stats()->ready.pick.pop.local++;
-				}
-			#endif
-
 			i %= count;
 			j %= count;
 
 			// try popping from the 2 picked lists
-			struct $thread * thrd = try_pop(cltr, i, j);
+			struct $thread * thrd = try_pop(cltr, i, j __STATS(, *(locali || localj ? &__tls_stats()->ready.pop.local : &__tls_stats()->ready.pop.help)));
 			if(thrd) {
-				#if !defined(__CFA_NO_STATISTICS__)
-					if( locali || localj ) __tls_stats()->ready.pick.pop.lsuccess++;
-				#endif
 				return thrd;
 			}
@@ -374,4 +361,9 @@
 		unsigned i;
 		do {
+			#if !defined(__CFA_NO_STATISTICS__)
+				if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.attempt, 1, __ATOMIC_RELAXED);
+				else __tls_stats()->ready.push.local.attempt++;
+			#endif
+
 			if(unlikely(external)) {
 				i = __tls_rand() % lanes.count;
@@ -398,4 +390,9 @@
 			// Unlock and return
 			__atomic_unlock( &lanes.data[i].lock );
+		#endif
+
+		#if !defined(__CFA_NO_STATISTICS__)
+			if(unlikely(external)) __atomic_fetch_add(&cltr->stats->ready.push.extrn.success, 1, __ATOMIC_RELAXED);
+			else __tls_stats()->ready.push.local.success++;
 		#endif
 
@@ -422,5 +419,5 @@
 		}
 		else if(lanes.tscs[proc->rdq.target].tv < proc->rdq.cutoff) {
-			$thread * t = try_pop(cltr, proc->rdq.target);
+			$thread * t = try_pop(cltr, proc->rdq.target __STATS(, __tls_stats()->ready.pop.help));
 			proc->rdq.target = -1u;
 			if(t) return t;
@@ -429,5 +426,5 @@
 		for(READYQ_SHARD_FACTOR) {
 			unsigned i = proc->rdq.id + (--proc->rdq.itr % READYQ_SHARD_FACTOR);
-			if($thread * t = try_pop(cltr, i)) return t;
+			if($thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.local))) return t;
 		}
 		return 0p;
@@ -437,5 +434,5 @@
 		for(25) {
 			unsigned i = __tls_rand() % lanes.count;
-			$thread * t = try_pop(cltr, i);
+			$thread * t = try_pop(cltr, i __STATS(, __tls_stats()->ready.pop.steal));
 			if(t) return t;
 		}
@@ -453,17 +450,26 @@
 //-----------------------------------------------------------------------
 // try to pop from a lane given by index w
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned w) with (cltr->ready_queue) {
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned w __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
+	__STATS( stats.attempt++; )
+
 	// Get relevant elements locally
 	__intrusive_lane_t & lane = lanes.data[w];
 
 	// If list looks empty retry
-	if( is_empty(lane) ) return 0p;
+	if( is_empty(lane) ) {
+		__STATS( stats.espec++; )
+		return 0p;
+	}
 
 	// If we can't get the lock retry
-	if( !__atomic_try_acquire(&lane.lock) ) return 0p;
+	if( !__atomic_try_acquire(&lane.lock) ) {
+		__STATS( stats.elock++; )
+		return 0p;
+	}
 
 	// If list is empty, unlock and retry
 	if( is_empty(lane) ) {
 		__atomic_unlock(&lane.lock);
+		__STATS( stats.eempty++; )
 		return 0p;
 	}
@@ -480,7 +486,5 @@
 
 	// Update statistics
-	#if !defined(__CFA_NO_STATISTICS__)
-		__tls_stats()->ready.pick.pop.success++;
-	#endif
+	__STATS( stats.success++; )
 
 	#if defined(USE_WORK_STEALING)
@@ -501,5 +505,5 @@
 	for(i; count) {
 		unsigned idx = (offset + i) % count;
-		struct $thread * thrd = try_pop(cltr, idx);
+		struct $thread * thrd = try_pop(cltr, idx __STATS(, __tls_stats()->ready.pop.search));
 		if(thrd) {
 			return thrd;
@@ -539,9 +543,5 @@
 //-----------------------------------------------------------------------
 // Given 2 indexes, pick the list with the oldest push an try to pop from it
-static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j) with (cltr->ready_queue) {
-	#if !defined(__CFA_NO_STATISTICS__)
-		__tls_stats()->ready.pick.pop.attempt++;
-	#endif
-
+static inline struct $thread * try_pop(struct cluster * cltr, unsigned i, unsigned j __STATS(, __stats_readyQ_pop_t & stats)) with (cltr->ready_queue) {
 	// Pick the bet list
 	int w = i;
@@ -550,5 +550,5 @@
 	}
 
-	return try_pop(cltr, w);
+	return try_pop(cltr, w __STATS(, stats));
 }
 
Index: libcfa/src/concurrency/stats.cfa
===================================================================
--- libcfa/src/concurrency/stats.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ libcfa/src/concurrency/stats.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -10,17 +10,30 @@
 #if !defined(__CFA_NO_STATISTICS__)
 	void __init_stats( struct __stats_t * stats ) {
-		stats->ready.pick.push.attempt  = 0;
-		stats->ready.pick.push.success  = 0;
-		stats->ready.pick.push.local    = 0;
-		stats->ready.pick.push.lsuccess = 0;
-		stats->ready.pick.ext.attempt  = 0;
-		stats->ready.pick.ext.success  = 0;
-		stats->ready.pick.ext.local    = 0;
-		stats->ready.pick.ext.lsuccess = 0;
-		stats->ready.pick.pop .probe    = 0;
-		stats->ready.pick.pop .attempt  = 0;
-		stats->ready.pick.pop .success  = 0;
-		stats->ready.pick.pop .local    = 0;
-		stats->ready.pick.pop .lsuccess = 0;
+		stats->ready.push.local.attempt = 0;
+		stats->ready.push.local.success = 0;
+		stats->ready.push.share.attempt = 0;
+		stats->ready.push.share.success = 0;
+		stats->ready.push.extrn.attempt = 0;
+		stats->ready.push.extrn.success = 0;
+		stats->ready.pop.local .attempt = 0;
+		stats->ready.pop.local .success = 0;
+		stats->ready.pop.local .elock   = 0;
+		stats->ready.pop.local .eempty  = 0;
+		stats->ready.pop.local .espec   = 0;
+		stats->ready.pop.help  .attempt = 0;
+		stats->ready.pop.help  .success = 0;
+		stats->ready.pop.help  .elock   = 0;
+		stats->ready.pop.help  .eempty  = 0;
+		stats->ready.pop.help  .espec   = 0;
+		stats->ready.pop.steal .attempt = 0;
+		stats->ready.pop.steal .success = 0;
+		stats->ready.pop.steal .elock   = 0;
+		stats->ready.pop.steal .eempty  = 0;
+		stats->ready.pop.steal .espec   = 0;
+		stats->ready.pop.search.attempt = 0;
+		stats->ready.pop.search.success = 0;
+		stats->ready.pop.search.elock   = 0;
+		stats->ready.pop.search.eempty  = 0;
+		stats->ready.pop.search.espec   = 0;
 		stats->ready.threads.migration = 0;
 		stats->ready.threads.threads   = 0;
@@ -54,17 +67,30 @@
 
 	void __tally_stats( struct __stats_t * cltr, struct __stats_t * proc ) {
-		__atomic_fetch_add( &cltr->ready.pick.push.attempt , proc->ready.pick.push.attempt , __ATOMIC_SEQ_CST ); proc->ready.pick.push.attempt  = 0;
-		__atomic_fetch_add( &cltr->ready.pick.push.success , proc->ready.pick.push.success , __ATOMIC_SEQ_CST ); proc->ready.pick.push.success  = 0;
-		__atomic_fetch_add( &cltr->ready.pick.push.local   , proc->ready.pick.push.local   , __ATOMIC_SEQ_CST ); proc->ready.pick.push.local    = 0;
-		__atomic_fetch_add( &cltr->ready.pick.push.lsuccess, proc->ready.pick.push.lsuccess, __ATOMIC_SEQ_CST ); proc->ready.pick.push.lsuccess = 0;
-		__atomic_fetch_add( &cltr->ready.pick.ext.attempt  , proc->ready.pick.ext.attempt  , __ATOMIC_SEQ_CST ); proc->ready.pick.ext.attempt   = 0;
-		__atomic_fetch_add( &cltr->ready.pick.ext.success  , proc->ready.pick.ext.success  , __ATOMIC_SEQ_CST ); proc->ready.pick.ext.success   = 0;
-		__atomic_fetch_add( &cltr->ready.pick.ext.local    , proc->ready.pick.ext.local    , __ATOMIC_SEQ_CST ); proc->ready.pick.ext.local     = 0;
-		__atomic_fetch_add( &cltr->ready.pick.ext.lsuccess , proc->ready.pick.ext.lsuccess , __ATOMIC_SEQ_CST ); proc->ready.pick.ext.lsuccess  = 0;
-		__atomic_fetch_add( &cltr->ready.pick.pop .probe   , proc->ready.pick.pop .probe   , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .probe    = 0;
-		__atomic_fetch_add( &cltr->ready.pick.pop .attempt , proc->ready.pick.pop .attempt , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .attempt  = 0;
-		__atomic_fetch_add( &cltr->ready.pick.pop .success , proc->ready.pick.pop .success , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .success  = 0;
-		__atomic_fetch_add( &cltr->ready.pick.pop .local   , proc->ready.pick.pop .local   , __ATOMIC_SEQ_CST ); proc->ready.pick.pop .local    = 0;
-		__atomic_fetch_add( &cltr->ready.pick.pop .lsuccess, proc->ready.pick.pop .lsuccess, __ATOMIC_SEQ_CST ); proc->ready.pick.pop .lsuccess = 0;
+		__atomic_fetch_add( &cltr->ready.push.local.attempt, proc->ready.push.local.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.local.attempt = 0;
+		__atomic_fetch_add( &cltr->ready.push.local.success, proc->ready.push.local.success, __ATOMIC_SEQ_CST ); proc->ready.push.local.success = 0;
+		__atomic_fetch_add( &cltr->ready.push.share.attempt, proc->ready.push.share.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.share.attempt = 0;
+		__atomic_fetch_add( &cltr->ready.push.share.success, proc->ready.push.share.success, __ATOMIC_SEQ_CST ); proc->ready.push.share.success = 0;
+		__atomic_fetch_add( &cltr->ready.push.extrn.attempt, proc->ready.push.extrn.attempt, __ATOMIC_SEQ_CST ); proc->ready.push.extrn.attempt = 0;
+		__atomic_fetch_add( &cltr->ready.push.extrn.success, proc->ready.push.extrn.success, __ATOMIC_SEQ_CST ); proc->ready.push.extrn.success = 0;
+		__atomic_fetch_add( &cltr->ready.pop.local .attempt, proc->ready.pop.local .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.local .attempt = 0;
+		__atomic_fetch_add( &cltr->ready.pop.local .success, proc->ready.pop.local .success, __ATOMIC_SEQ_CST ); proc->ready.pop.local .success = 0;
+		__atomic_fetch_add( &cltr->ready.pop.local .elock  , proc->ready.pop.local .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.local .elock   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.local .eempty , proc->ready.pop.local .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.local .eempty  = 0;
+		__atomic_fetch_add( &cltr->ready.pop.local .espec  , proc->ready.pop.local .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.local .espec   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.help  .attempt, proc->ready.pop.help  .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.help  .attempt = 0;
+		__atomic_fetch_add( &cltr->ready.pop.help  .success, proc->ready.pop.help  .success, __ATOMIC_SEQ_CST ); proc->ready.pop.help  .success = 0;
+		__atomic_fetch_add( &cltr->ready.pop.help  .elock  , proc->ready.pop.help  .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .elock   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.help  .eempty , proc->ready.pop.help  .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .eempty  = 0;
+		__atomic_fetch_add( &cltr->ready.pop.help  .espec  , proc->ready.pop.help  .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.help  .espec   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.steal .attempt, proc->ready.pop.steal .attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.steal .attempt = 0;
+		__atomic_fetch_add( &cltr->ready.pop.steal .success, proc->ready.pop.steal .success, __ATOMIC_SEQ_CST ); proc->ready.pop.steal .success = 0;
+		__atomic_fetch_add( &cltr->ready.pop.steal .elock  , proc->ready.pop.steal .elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .elock   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.steal .eempty , proc->ready.pop.steal .eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .eempty  = 0;
+		__atomic_fetch_add( &cltr->ready.pop.steal .espec  , proc->ready.pop.steal .espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.steal .espec   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.search.attempt, proc->ready.pop.search.attempt, __ATOMIC_SEQ_CST ); proc->ready.pop.search.attempt = 0;
+		__atomic_fetch_add( &cltr->ready.pop.search.success, proc->ready.pop.search.success, __ATOMIC_SEQ_CST ); proc->ready.pop.search.success = 0;
+		__atomic_fetch_add( &cltr->ready.pop.search.elock  , proc->ready.pop.search.elock  , __ATOMIC_SEQ_CST ); proc->ready.pop.search.elock   = 0;
+		__atomic_fetch_add( &cltr->ready.pop.search.eempty , proc->ready.pop.search.eempty , __ATOMIC_SEQ_CST ); proc->ready.pop.search.eempty  = 0;
+		__atomic_fetch_add( &cltr->ready.pop.search.espec  , proc->ready.pop.search.espec  , __ATOMIC_SEQ_CST ); proc->ready.pop.search.espec   = 0;
 		__atomic_fetch_add( &cltr->ready.threads.migration , proc->ready.threads.migration , __ATOMIC_SEQ_CST ); proc->ready.threads.migration  = 0;
 		__atomic_fetch_add( &cltr->ready.threads.threads   , proc->ready.threads.threads   , __ATOMIC_SEQ_CST ); proc->ready.threads.threads    = 0;
@@ -95,27 +121,33 @@
 
 		if( flags & CFA_STATS_READY_Q ) {
-			double push_len = ((double)ready.pick.push.attempt) / ready.pick.push.success;
-			double ext_len  = ((double)ready.pick.ext .attempt) / ready.pick.ext .success;
-			double pop_len  = ((double)ready.pick.pop .attempt) / ready.pick.pop .success;
-
-			double lpush_len = ((double)ready.pick.push.local) / ready.pick.push.lsuccess;
-			double lext_len  = ((double)ready.pick.ext .local) / ready.pick.ext .lsuccess;
-			double lpop_len  = ((double)ready.pick.pop .local) / ready.pick.pop .lsuccess;
+			double push_len = ((double)ready.push.local.attempt + ready.push.share.attempt + ready.push.extrn.attempt) / (ready.push.local.success + ready.push.share.success + ready.push.extrn.success);
+			double sLcl_len = ready.push.local.success ? ((double)ready.push.local.attempt) / ready.push.local.success : 0;
+			double sOth_len = ready.push.share.success ? ((double)ready.push.share.attempt) / ready.push.share.success : 0;
+			double sExt_len = ready.push.extrn.success ? ((double)ready.push.extrn.attempt) / ready.push.extrn.success : 0;
+
+			double rLcl_len  = ready.pop.local .success ? ((double)ready.pop.local .attempt) / ready.pop.local .success : 0;
+			double rHlp_len  = ready.pop.help  .success ? ((double)ready.pop.help  .attempt) / ready.pop.help  .success : 0;
+			double rStl_len  = ready.pop.steal .success ? ((double)ready.pop.steal .attempt) / ready.pop.steal .success : 0;
+			double rSch_len  = ready.pop.search.success ? ((double)ready.pop.search.attempt) / ready.pop.search.success : 0;
 
 			__cfaabi_bits_print_safe( STDOUT_FILENO,
 				"----- %s \"%s\" (%p) - Ready Q Stats -----\n"
-				"- total threads  : %'15" PRIu64 "run, %'15" PRIu64 "schd (%'" PRIu64 "ext, %'" PRIu64 "mig, %'" PRId64 " )\n"
-				"- push avg probe : %'3.2lf, %'3.2lfl (%'15" PRIu64 " attempts, %'15" PRIu64 " locals)\n"
-				"- ext  avg probe : %'3.2lf, %'3.2lfl (%'15" PRIu64 " attempts, %'15" PRIu64 " locals)\n"
-				"- pop  avg probe : %'3.2lf, %'3.2lfl (%'15" PRIu64 " attempts, %'15" PRIu64 " locals)\n"
-				"- Idle Sleep     : %'15" PRIu64 "h, %'15" PRIu64 "c, %'15" PRIu64 "w, %'15" PRIu64 "e\n"
+				"- totals   : %'3" PRIu64 " run, %'3" PRIu64 " schd (%'" PRIu64 "ext, %'" PRIu64 "mig, %'" PRId64 " )\n"
+				"- push avg : %'3.2lf (l: %'3.2lf/%'" PRIu64 ", s: %'3.2lf/%'" PRIu64 ", e: %'3.2lf : %'" PRIu64 "e)\n"
+				"- local    : %'3.2lf (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
+				"- help     : %'3.2lf (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
+				"- steal    : %'3.2lf (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
+				"- search   : %'3.2lf (%'3" PRIu64 " try, %'3" PRIu64 " spc, %'3" PRIu64 " lck, %'3" PRIu64 " ept)\n"
+				"- Idle Slp : %'3" PRIu64 "h, %'3" PRIu64 "c, %'3" PRIu64 "w, %'3" PRIu64 "e\n"
 				"\n"
 				, type, name, id
-				, ready.pick.pop.success
-				, ready.pick.push.success + ready.pick.ext.success
-				, ready.pick.ext.success, ready.threads.migration, ready.threads.threads
-				, push_len, lpush_len, ready.pick.push.attempt, ready.pick.push.local
-				, ext_len , lext_len , ready.pick.ext .attempt, ready.pick.ext .local
-				, pop_len , lpop_len , ready.pick.pop .attempt, ready.pick.pop .local
+				, ready.pop.local.success + ready.pop.help.success + ready.pop.steal.success + ready.pop.search.success
+				, ready.push.local.success + ready.push.share.success + ready.push.extrn.success
+				, ready.push.extrn.success, ready.threads.migration, ready.threads.threads
+				, push_len, sLcl_len, ready.push.local.attempt, sOth_len, ready.push.share.attempt, sExt_len, ready.push.extrn.attempt
+				, rLcl_len, ready.pop.local .attempt, ready.pop.local .espec, ready.pop.local .elock, ready.pop.local .eempty
+				, rHlp_len, ready.pop.help  .attempt, ready.pop.help  .espec, ready.pop.help  .elock, ready.pop.help  .eempty
+				, rStl_len, ready.pop.steal .attempt, ready.pop.steal .espec, ready.pop.steal .elock, ready.pop.steal .eempty
+				, rSch_len, ready.pop.search.attempt, ready.pop.search.espec, ready.pop.search.elock, ready.pop.search.eempty
 				, ready.sleep.halts, ready.sleep.cancels, ready.sleep.wakes, ready.sleep.exits
 			);
Index: libcfa/src/concurrency/stats.hfa
===================================================================
--- libcfa/src/concurrency/stats.hfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ libcfa/src/concurrency/stats.hfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -16,56 +16,56 @@
 	static inline void __print_stats( struct __stats_t *, int, const char *, const char *, void * ) {}
 #else
+	struct __stats_readyQ_pop_t {
+		// number of attemps at poping something
+		volatile uint64_t attempt;
 
-	struct __attribute__((aligned(64))) __stats_readQ_t {
+		// number of successes at poping
+		volatile uint64_t success;
+
+		// number of attempts failed due to the lock being held
+		volatile uint64_t elock;
+
+		// number of attempts failed due to the queue being empty (lock held)
+		volatile uint64_t eempty;
+
+		// number of attempts failed due to the queue looking empty (lock not held)
+		volatile uint64_t espec;
+	};
+
+	struct __attribute__((aligned(64))) __stats_readyQ_t {
+		// Push statistic
 		struct {
-			// Push statistic
 			struct {
-				// number of attemps at pushing something
+				// number of attemps at pushing something to preferred queues
 				volatile uint64_t attempt;
 
-				// number of successes at pushing
+				// number of successes at pushing to preferred queues
 				volatile uint64_t success;
+			}
+			// Stats for local queue within cluster
+			local,
 
-				// number of attemps at pushing something to preferred queues
-				volatile uint64_t local;
+			// Stats for non-local queues within cluster
+			share,
 
-				// number of successes at pushing to preferred queues
-				volatile uint64_t lsuccess;
-			} push;
+			// Stats from outside cluster
+			extrn;
+		} push;
 
-			struct {
-				// number of attemps at pushing something
-				volatile uint64_t attempt;
+		// Pop statistic
+		struct {
+			// pop from local queue
+			__stats_readyQ_pop_t local;
 
-				// number of successes at pushing
-				volatile uint64_t success;
+			// pop before looking at local queue
+			__stats_readyQ_pop_t help;
 
-				// number of attemps at pushing something to preferred queues
-				volatile uint64_t local;
+			// pop from some other queue
+			__stats_readyQ_pop_t steal;
 
-				// number of successes at pushing to preferred queues
-				volatile uint64_t lsuccess;
-			} ext;
+			// pop when searching queues sequentially
+			__stats_readyQ_pop_t search;
+		} pop;
 
-			// Pop statistic
-			struct {
-				// number of reads of the mask
-				// picking an empty __cfa_readyQ_mask_t counts here
-				// but not as an attempt
-				volatile uint64_t probe;
-
-				// number of attemps at poping something
-				volatile uint64_t attempt;
-
-				// number of successes at poping
-				volatile uint64_t success;
-
-				// number of attemps at poping something to preferred queues
-				volatile uint64_t local;
-
-				// number of successes at poping to preferred queues
-				volatile uint64_t lsuccess;
-			} pop;
-		} pick;
 		struct {
 			volatile uint64_t migration;
@@ -119,5 +119,5 @@
 
 	struct __attribute__((aligned(128))) __stats_t {
-		__stats_readQ_t ready;
+		__stats_readyQ_t ready;
 		#if defined(CFA_HAVE_LINUX_IO_URING_H)
 			__stats_io_t    io;
Index: tests/time.cfa
===================================================================
--- tests/time.cfa	(revision c8a02103529bbac3a87ecc27896ddaea00e4e292)
+++ tests/time.cfa	(revision 665edf40670b0348b31fea1a21e2dd886e4125e2)
@@ -10,6 +10,6 @@
 // Created On       : Tue Mar 27 17:24:56 2018
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Jun 18 18:14:49 2020
-// Update Count     : 37
+// Last Modified On : Fri Apr 16 14:59:53 2021
+// Update Count     : 38
 //
 
@@ -53,5 +53,5 @@
 	// 	 | "Newfoundland" | getTime( Newfoundland )
 	// 	 | "local" | getTime()
-	// 	 | "local nsec" | getTimeNsec()
+	// 	 | "local nsec" | timeHiRes()
 	// 	 | "PST" | PST();								// getTime short form
 	// sout | nl;
