Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision 0a55a53ade297b19f79353b21346a7e4dd7636a6)
+++ libcfa/src/concurrency/locks.hfa	(revision bbe3719f51f151b5ad865f6a0ca92c072ca4f23e)
@@ -324,62 +324,4 @@
 	}
 
-	// linear backoff bounded by spin_count
-	spin = spin_start;
-	int spin_counter = 0;
-	int yield_counter = 0;
-	for ( ;; ) {
-		if(try_lock_contention(this)) return true;
-		if(spin_counter < spin_count) {
-			for (int i = 0; i < spin; i++) Pause();
-			if (spin < spin_end) spin += spin;
-			else spin_counter++;
-		} else if (yield_counter < yield_count) {
-			// after linear backoff yield yield_count times
-			yield_counter++;
-			yield();
-		} else { break; }
-	}
-
-	// block until signalled
-	while (block(this)) if(try_lock_contention(this)) return true;
-
-	// this should never be reached as block(this) always returns true
-	return false;
-}
-
-static inline bool lock_improved(linear_backoff_then_block_lock & this) with(this) {
-	// if owner just return
-	if (active_thread() == owner) return true;
-	size_t compare_val = 0;
-	int spin = spin_start;
-	// linear backoff
-	for( ;; ) {
-		compare_val = 0;
-		if (internal_try_lock(this, compare_val)) return true;
-		if (2 == compare_val) break;
-		for (int i = 0; i < spin; i++) Pause();
-		if (spin >= spin_end) break;
-		spin += spin;
-	}
-
-	// linear backoff bounded by spin_count
-	spin = spin_start;
-	int spin_counter = 0;
-	int yield_counter = 0;
-	for ( ;; ) {
-		compare_val = 0;
-		if(internal_try_lock(this, compare_val)) return true;
-		if (2 == compare_val) break;
-		if(spin_counter < spin_count) {
-			for (int i = 0; i < spin; i++) Pause();
-			if (spin < spin_end) spin += spin;
-			else spin_counter++;
-		} else if (yield_counter < yield_count) {
-			// after linear backoff yield yield_count times
-			yield_counter++;
-			yield();
-		} else { break; }
-	}
-
 	if(2 != compare_val && try_lock_contention(this)) return true;
 	// block until signalled
@@ -402,5 +344,5 @@
 static inline void on_notify(linear_backoff_then_block_lock & this, struct thread$ * t ) { unpark(t); }
 static inline size_t on_wait(linear_backoff_then_block_lock & this) { unlock(this); return 0; }
-static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock_improved(this); }
+static inline void on_wakeup(linear_backoff_then_block_lock & this, size_t recursion ) { lock(this); }
 
 //-----------------------------------------------------------------------------
Index: libcfa/src/concurrency/mutex_stmt.hfa
===================================================================
--- libcfa/src/concurrency/mutex_stmt.hfa	(revision 0a55a53ade297b19f79353b21346a7e4dd7636a6)
+++ libcfa/src/concurrency/mutex_stmt.hfa	(revision bbe3719f51f151b5ad865f6a0ca92c072ca4f23e)
@@ -40,7 +40,3 @@
         }
     }
-
-    static inline L * __get_pointer( L & lock ) {
-        return &lock;
-    }
 }
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 0a55a53ade297b19f79353b21346a7e4dd7636a6)
+++ src/Concurrency/Keywords.cc	(revision bbe3719f51f151b5ad865f6a0ca92c072ca4f23e)
@@ -1208,8 +1208,5 @@
 			new ListInit(
 				map_range < std::list<Initializer*> > ( args, [](Expression * var ){
-					return new SingleInit( new UntypedExpr(
-						new NameExpr( "__get_pointer" ),
-						{ var }
-					) );
+					return new SingleInit( new AddressExpr( var ) );
 				})
 			)
Index: tests/concurrent/mutexstmt/locks.cfa
===================================================================
--- tests/concurrent/mutexstmt/locks.cfa	(revision 0a55a53ade297b19f79353b21346a7e4dd7636a6)
+++ tests/concurrent/mutexstmt/locks.cfa	(revision bbe3719f51f151b5ad865f6a0ca92c072ca4f23e)
@@ -4,5 +4,5 @@
 const unsigned int num_times = 10000;
 
-owner_lock m1, m2, m3, m4, m5;
+single_acquisition_lock m1, m2, m3, m4, m5;
 
 thread T_Mutex {};
@@ -65,5 +65,5 @@
 	printf("Start Test: single lock mutual exclusion\n");
 	{
-		T_Mutex t[1];
+		T_Mutex t[10];
 	}
 	printf("End Test: single lock mutual exclusion\n");