Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 69914cbc38918b375971f7accca59529f62f2d08)
+++ libcfa/src/concurrency/kernel.cfa	(revision e2f601f4328a2fea1024c253b1f150202c44c9e3)
@@ -182,5 +182,6 @@
 		MAIN_LOOP:
 		for() {
-			#if 1
+			#define OLD_MAIN 1
+			#if OLD_MAIN
 			// Check if there is pending io
 			__maybe_io_drain( this );
@@ -262,8 +263,7 @@
 
 			#else
-
+				#warning new kernel loop
 			SEARCH: {
 				/* paranoid */ verify( ! __preemption_enabled() );
-				/* paranoid */ verify( kernelTLS().this_proc_id );
 
 				// First, lock the scheduler since we are searching for a thread
@@ -278,5 +278,5 @@
 
 				// Spin a little on I/O, just in case
-				for(25) {
+					for(5) {
 					__maybe_io_drain( this );
 					readyThread = pop_fast( this->cltr );
@@ -285,5 +285,5 @@
 
 				// no luck, try stealing a few times
-				for(25) {
+					for(5) {
 					if( __maybe_io_drain( this ) ) {
 						readyThread = pop_fast( this->cltr );
@@ -323,5 +323,5 @@
 				}
 
-				__STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->id, rdtscl()); )
+					__STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 0\n", this->unique_id, rdtscl()); )
 				__cfadbg_print_safe(runtime_core, "Kernel : core %p waiting on eventfd %d\n", this, this->idle);
 
@@ -331,5 +331,5 @@
 				// __enable_interrupts_hard();
 
-				__STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->id, rdtscl()); )
+					__STATS( if(this->print_halts) __cfaabi_bits_print_safe( STDOUT_FILENO, "PH:%d - %lld 1\n", this->unique_id, rdtscl()); )
 
 				// We were woken up, remove self from idle
@@ -341,5 +341,4 @@
 
 		RUN_THREAD:
-			/* paranoid */ verify( kernelTLS().this_proc_id );
 			/* paranoid */ verify( ! __preemption_enabled() );
 			/* paranoid */ verify( readyThread );
@@ -353,12 +352,4 @@
 			// Are we done?
 			if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-			#if !defined(__CFA_NO_STATISTICS__)
-				unsigned long long curr = rdtscl();
-				if(curr > (last_tally + 500000000)) {
-					__tally_stats(this->cltr->stats, __cfaabi_tls.this_stats);
-					last_tally = curr;
-				}
-			#endif
 
 			if(this->io.pending && !this->io.dirty) {
@@ -877,7 +868,11 @@
 		unsigned tail = *ctx->cq.tail;
 		if(head == tail) return false;
+		#if OLD_MAIN
 		ready_schedule_lock();
 		ret = __cfa_io_drain( proc );
 		ready_schedule_unlock();
+		#else
+			ret = __cfa_io_drain( proc );
+	#endif
 	#endif
 	return ret;
Index: libcfa/src/concurrency/kernel.hfa
===================================================================
--- libcfa/src/concurrency/kernel.hfa	(revision 69914cbc38918b375971f7accca59529f62f2d08)
+++ libcfa/src/concurrency/kernel.hfa	(revision e2f601f4328a2fea1024c253b1f150202c44c9e3)
@@ -147,7 +147,10 @@
 
 // Aligned timestamps which are used by the relaxed ready queue
-struct __attribute__((aligned(128))) __timestamp_t;
-void  ?{}(__timestamp_t & this);
-void ^?{}(__timestamp_t & this);
+struct __attribute__((aligned(128))) __timestamp_t {
+	volatile unsigned long long tv;
+};
+
+static inline void  ?{}(__timestamp_t & this) { this.tv = 0; }
+static inline void ^?{}(__timestamp_t & this) {}
 
 //TODO adjust cache size to ARCHITECTURE
@@ -172,4 +175,7 @@
 void  ?{}(__ready_queue_t & this);
 void ^?{}(__ready_queue_t & this);
+#if !defined(__CFA_NO_STATISTICS__)
+	unsigned cnt(const __ready_queue_t & this, unsigned idx);
+#endif
 
 // Idle Sleep
Index: libcfa/src/concurrency/kernel/startup.cfa
===================================================================
--- libcfa/src/concurrency/kernel/startup.cfa	(revision 69914cbc38918b375971f7accca59529f62f2d08)
+++ libcfa/src/concurrency/kernel/startup.cfa	(revision e2f601f4328a2fea1024c253b1f150202c44c9e3)
@@ -496,5 +496,5 @@
 	this.rdq.id  = -1u;
 	this.rdq.target = -1u;
-	this.rdq.cutoff = -1ull;
+	this.rdq.cutoff = 0ull;
 	do_terminate = false;
 	preemption_alarm = 0p;
Index: libcfa/src/concurrency/ready_queue.cfa
===================================================================
--- libcfa/src/concurrency/ready_queue.cfa	(revision 69914cbc38918b375971f7accca59529f62f2d08)
+++ libcfa/src/concurrency/ready_queue.cfa	(revision e2f601f4328a2fea1024c253b1f150202c44c9e3)
@@ -398,13 +398,11 @@
 
 		if(proc->rdq.target == -1u) {
-			_Static_assert(READYQ_SHARD_FACTOR == 2);
-			unsigned idx1 = proc->rdq.id + 0;
-			unsigned idx2 = proc->rdq.id + 1;
-			unsigned long long tsc1 = ts(lanes.data[idx1]);
-			unsigned long long tsc2 = ts(lanes.data[idx2]);
+			unsigned long long min = ts(lanes.data[proc->rdq.id]);
+			for(int i = 0; i < READYQ_SHARD_FACTOR; i++) {
+				unsigned long long tsc = ts(lanes.data[proc->rdq.id + i]);
+				if(tsc < min) min = tsc;
+			}
+			proc->rdq.cutoff = min;
 			proc->rdq.target = __tls_rand() % lanes.count;
-
-			// WARNING: std::min is polymorphic and therefore causes 500% slowdown instead of the expected 2%
-			proc->rdq.cutoff = tsc1 < tsc2 ? tsc1 : tsc2;
 		}
 		else {
@@ -704,2 +702,9 @@
 	/* paranoid */ verify( ready_mutate_islocked() );
 }
+
+#if !defined(__CFA_NO_STATISTICS__)
+	unsigned cnt(const __ready_queue_t & this, unsigned idx) {
+		/* paranoid */ verify(this.lanes.count > idx);
+		return this.lanes.data[idx].cnt;
+	}
+#endif
Index: libcfa/src/concurrency/ready_subqueue.hfa
===================================================================
--- libcfa/src/concurrency/ready_subqueue.hfa	(revision 69914cbc38918b375971f7accca59529f62f2d08)
+++ libcfa/src/concurrency/ready_subqueue.hfa	(revision e2f601f4328a2fea1024c253b1f150202c44c9e3)
@@ -11,4 +11,8 @@
 	// spin lock protecting the queue
 	volatile bool lock;
+
+	#if !defined(__CFA_NO_STATISTICS__)
+		unsigned cnt;
+	#endif
 
 	__thread_desc_link anchor;
@@ -29,6 +33,10 @@
 	this.anchor.next = 0p;
 	this.anchor.ts   = 0;
+	#if !defined(__CFA_NO_STATISTICS__)
+		this.cnt  = 0;
+	#endif
 
 	// We add a boat-load of assertions here because the anchor code is very fragile
+	/* paranoid */ _Static_assert( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
 	/* paranoid */ verify( offsetof( $thread, link ) == offsetof(__intrusive_lane_t, anchor) );
 	/* paranoid */ verify( ((uintptr_t)( mock_head(this) ) + offsetof( $thread, link )) == (uintptr_t)(&this.anchor) );
@@ -54,4 +62,5 @@
 // returns true of lane was empty before push, false otherwise
 static inline void push( __intrusive_lane_t & this, $thread * node ) {
+	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( node->link.next == 0p );
 	/* paranoid */ verify( node->link.ts   == 0  );
@@ -72,4 +81,7 @@
 	this.prev->link.ts   = rdtscl();
 	this.prev = node;
+	#if !defined(__CFA_NO_STATISTICS__)
+		this.cnt++;
+	#endif
 }
 
@@ -78,4 +90,5 @@
 // returns true of lane was empty before push, false otherwise
 static inline [* $thread, unsigned long long] pop( __intrusive_lane_t & this ) {
+	/* paranoid */ verify( this.lock );
 	/* paranoid */ verify( this.anchor.next != 0p );
 	/* paranoid */ verify( this.anchor.ts   != 0  );
@@ -89,4 +102,7 @@
 	node->link.next = 0p;
 	node->link.ts   = 0;
+	#if !defined(__CFA_NO_STATISTICS__)
+		this.cnt--;
+	#endif
 
 	// Update head time stamp
@@ -108,10 +124,2 @@
 	return this.anchor.ts;
 }
-
-// Aligned timestamps which are used by the relaxed ready queue
-struct __attribute__((aligned(128))) __timestamp_t {
-	volatile unsigned long long tv;
-};
-
-void  ?{}(__timestamp_t & this) { this.tv = 0; }
-void ^?{}(__timestamp_t & this) {}
