Index: libcfa/src/concurrency/ready_subqueue.hfa
===================================================================
--- libcfa/src/concurrency/ready_subqueue.hfa	(revision b0be371326150c4c81c3eee020eda41c12571997)
+++ libcfa/src/concurrency/ready_subqueue.hfa	(revision c4c8571a1aaa3100966db2d603b3a32857faebdd)
@@ -6,15 +6,18 @@
 
 // Intrusives lanes which are used by the relaxed ready queue
-struct __attribute__((aligned(128))) __intrusive_lane_t {
-	struct thread$ * prev;
+union __attribute__((aligned(64))) __intrusive_lane_t {
+	struct {
+		struct thread$ * prev;
 
-	// spin lock protecting the queue
-	volatile bool lock;
+		// spin lock protecting the queue
+		volatile bool lock;
 
-	__thread_desc_link anchor;
+		__thread_desc_link anchor;
 
-	#if !defined(__CFA_NO_STATISTICS__)
-		unsigned cnt;
-	#endif
+		#if !defined(__CFA_NO_STATISTICS__)
+			unsigned cnt;
+		#endif
+	} l;
+	char __padding[192];
 };
 
@@ -22,5 +25,5 @@
 static inline thread$ * mock_head(const __intrusive_lane_t & this) {
 	thread$ * rhead = (thread$ *)(
-		(uintptr_t)( &this.anchor ) - __builtin_offsetof( thread$, link )
+		(uintptr_t)( &this.l.anchor ) - __builtin_offsetof( thread$, link )
 	);
 	return rhead;
@@ -30,27 +33,27 @@
 // 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( this.l.lock );
 	/* paranoid */ verify( node->link.next == 0p );
 	/* paranoid */ verify( __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED) == MAX  );
-	/* paranoid */ verify( this.prev->link.next == 0p );
-	/* paranoid */ verify( __atomic_load_n(&this.prev->link.ts, __ATOMIC_RELAXED)   == MAX  );
-	if( this.anchor.next == 0p ) {
-		/* paranoid */ verify( this.anchor.next == 0p );
-		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) == MAX );
-		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0  );
-		/* paranoid */ verify( this.prev == mock_head( this ) );
+	/* paranoid */ verify( this.l.prev->link.next == 0p );
+	/* paranoid */ verify( __atomic_load_n(&this.l.prev->link.ts, __ATOMIC_RELAXED)   == MAX  );
+	if( this.l.anchor.next == 0p ) {
+		/* paranoid */ verify( this.l.anchor.next == 0p );
+		/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) == MAX );
+		/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) != 0  );
+		/* paranoid */ verify( this.l.prev == mock_head( this ) );
 	} else {
-		/* paranoid */ verify( this.anchor.next != 0p );
-		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != MAX );
-		/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0  );
-		/* paranoid */ verify( this.prev != mock_head( this ) );
+		/* paranoid */ verify( this.l.anchor.next != 0p );
+		/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) != MAX );
+		/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) != 0  );
+		/* paranoid */ verify( this.l.prev != mock_head( this ) );
 	}
 
 	// Get the relevant nodes locally
-	this.prev->link.next = node;
-	__atomic_store_n(&this.prev->link.ts, rdtscl(), __ATOMIC_RELAXED);
-	this.prev = node;
+	this.l.prev->link.next = node;
+	__atomic_store_n(&this.l.prev->link.ts, rdtscl(), __ATOMIC_RELAXED);
+	this.l.prev = node;
 	#if !defined(__CFA_NO_STATISTICS__)
-		this.cnt++;
+		this.l.cnt++;
 	#endif
 }
@@ -60,24 +63,24 @@
 // 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( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != MAX );
-	/* paranoid */ verify( __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED) != 0   );
+	/* paranoid */ verify( this.l.lock );
+	/* paranoid */ verify( this.l.anchor.next != 0p );
+	/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) != MAX );
+	/* paranoid */ verify( __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED) != 0   );
 
 	// Get the relevant nodes locally
-	thread$ * node = this.anchor.next;
-	this.anchor.next = node->link.next;
-	__atomic_store_n(&this.anchor.ts, __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED), __ATOMIC_RELAXED);
-	bool is_empty = this.anchor.next == 0p;
+	thread$ * node = this.l.anchor.next;
+	this.l.anchor.next = node->link.next;
+	__atomic_store_n(&this.l.anchor.ts, __atomic_load_n(&node->link.ts, __ATOMIC_RELAXED), __ATOMIC_RELAXED);
+	bool is_empty = this.l.anchor.next == 0p;
 	node->link.next = 0p;
 	__atomic_store_n(&node->link.ts, ULLONG_MAX, __ATOMIC_RELAXED);
 	#if !defined(__CFA_NO_STATISTICS__)
-		this.cnt--;
+		this.l.cnt--;
 	#endif
 
 	// Update head time stamp
-	if(is_empty) this.prev = mock_head( this );
+	if(is_empty) this.l.prev = mock_head( this );
 
-	unsigned long long ats = __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED);
+	unsigned long long ats = __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED);
 	/* paranoid */ verify( node->link.next == 0p );
 	/* paranoid */ verify( __atomic_load_n(&node->link.ts , __ATOMIC_RELAXED) == MAX );
@@ -90,5 +93,5 @@
 // Check whether or not list is empty
 static inline bool is_empty(__intrusive_lane_t & this) {
-	return this.anchor.next == 0p;
+	return this.l.anchor.next == 0p;
 }
 
@@ -96,6 +99,6 @@
 static inline unsigned long long ts(__intrusive_lane_t & this) {
 	// Cannot verify 'emptiness' here since it may not be locked
-	/* paranoid */ verify(this.anchor.ts != 0);
-	/* paranoid */ static_assert(__atomic_always_lock_free(sizeof(this.anchor.ts), &this.anchor.ts));
-	return __atomic_load_n(&this.anchor.ts, __ATOMIC_RELAXED);
+	/* paranoid */ verify(this.l.anchor.ts != 0);
+	/* paranoid */ static_assert(__atomic_always_lock_free(sizeof(this.l.anchor.ts), &this.l.anchor.ts));
+	return __atomic_load_n(&this.l.anchor.ts, __ATOMIC_RELAXED);
 }
