Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ libcfa/src/concurrency/locks.hfa	(revision 0fc447c38ee7b02d6cdb7bd08aef617ade5852c7)
@@ -29,103 +29,4 @@
 #include "time_t.hfa"
 #include "time.hfa"
-
-//-----------------------------------------------------------------------------
-// Semaphores
-
-// '0-nary' semaphore
-// Similar to a counting semaphore except the value of one is never reached
-// as a consequence, a V() that would bring the value to 1 *spins* until
-// a P consumes it
-struct Semaphore0nary {
-	__spinlock_t lock; // needed to protect
-	mpsc_queue(thread$) queue;
-};
-
-static inline bool P(Semaphore0nary & this, thread$ * thrd) {
-	/* paranoid */ verify(!thrd`next);
-	/* paranoid */ verify(!(&(*thrd)`next));
-
-	push(this.queue, thrd);
-	return true;
-}
-
-static inline bool P(Semaphore0nary & this) {
-    thread$ * thrd = active_thread();
-    P(this, thrd);
-    park();
-    return true;
-}
-
-static inline thread$ * V(Semaphore0nary & this, bool doUnpark = true) {
-	thread$ * next;
-	lock(this.lock __cfaabi_dbg_ctx2);
-		for (;;) {
-			next = pop(this.queue);
-			if (next) break;
-			Pause();
-		}
-	unlock(this.lock);
-
-	if (doUnpark) unpark(next);
-	return next;
-}
-
-// Wrapper used on top of any sempahore to avoid potential locking
-struct BinaryBenaphore {
-	volatile ssize_t counter;
-};
-
-static inline {
-	void ?{}(BinaryBenaphore & this) { this.counter = 0; }
-	void ?{}(BinaryBenaphore & this, zero_t) { this.counter = 0; }
-	void ?{}(BinaryBenaphore & this, one_t ) { this.counter = 1; }
-
-	// returns true if no blocking needed
-	bool P(BinaryBenaphore & this) {
-		return __atomic_fetch_sub(&this.counter, 1, __ATOMIC_SEQ_CST) > 0;
-	}
-
-	bool tryP(BinaryBenaphore & this) {
-		ssize_t c = this.counter;
-		/* paranoid */ verify( c > MIN );
-		return (c >= 1) && __atomic_compare_exchange_n(&this.counter, &c, c-1, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
-	}
-
-	// returns true if notify needed
-	bool V(BinaryBenaphore & this) {
-		ssize_t c = 0;
-		for () {
-			/* paranoid */ verify( this.counter < MAX );
-			if (__atomic_compare_exchange_n(&this.counter, &c, c+1, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-				if (c == 0) return true;
-				/* paranoid */ verify(c < 0);
-				return false;
-			} else {
-				if (c == 1) return true;
-				/* paranoid */ verify(c < 1);
-				Pause();
-			}
-		}
-	}
-}
-
-// Binary Semaphore based on the BinaryBenaphore on top of the 0-nary Semaphore
-struct ThreadBenaphore {
-	BinaryBenaphore ben;
-	Semaphore0nary  sem;
-};
-
-static inline void ?{}(ThreadBenaphore & this) {}
-static inline void ?{}(ThreadBenaphore & this, zero_t) { (this.ben){ 0 }; }
-static inline void ?{}(ThreadBenaphore & this, one_t ) { (this.ben){ 1 }; }
-
-static inline bool P(ThreadBenaphore & this)              { return P(this.ben) ? false : P(this.sem); }
-static inline bool tryP(ThreadBenaphore & this)           { return tryP(this.ben); }
-static inline bool P(ThreadBenaphore & this, bool wait)   { return wait ? P(this) : tryP(this); }
-
-static inline thread$ * V(ThreadBenaphore & this, bool doUnpark = true) {
-	if (V(this.ben)) return 0p;
-	return V(this.sem, doUnpark);
-}
 
 //-----------------------------------------------------------------------------
@@ -171,51 +72,4 @@
 static inline void   on_wakeup( owner_lock & this, size_t v ) { on_wakeup ( (blocking_lock &)this, v ); }
 static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
-
-struct fast_lock {
-	thread$ * volatile owner;
-	ThreadBenaphore sem;
-};
-
-static inline void ?{}(fast_lock & this) __attribute__((deprecated("use linear_backoff_then_block_lock instead")));
-static inline void ?{}(fast_lock & this) { this.owner = 0p; }
-
-static inline bool $try_lock(fast_lock & this, thread$ * thrd) {
-    thread$ * exp = 0p;
-    return __atomic_compare_exchange_n(&this.owner, &exp, thrd, false, __ATOMIC_SEQ_CST, __ATOMIC_RELAXED);
-}
-
-static inline void lock( fast_lock & this ) __attribute__((deprecated("use linear_backoff_then_block_lock instead"), artificial));
-static inline void lock( fast_lock & this ) {
-	thread$ * thrd = active_thread();
-	/* paranoid */verify(thrd != this.owner);
-
-	for (;;) {
-		if ($try_lock(this, thrd)) return;
-		P(this.sem);
-	}
-}
-
-static inline bool try_lock( fast_lock & this ) __attribute__((deprecated("use linear_backoff_then_block_lock instead"), artificial));
-static inline bool try_lock ( fast_lock & this ) {
-	thread$ * thrd = active_thread();
-	/* paranoid */ verify(thrd != this.owner);
-	return $try_lock(this, thrd);
-}
-
-static inline thread$ * unlock( fast_lock & this ) __attribute__((deprecated("use linear_backoff_then_block_lock instead"), artificial));
-static inline thread$ * unlock( fast_lock & this ) {
-	/* paranoid */ verify(active_thread() == this.owner);
-
-	// open 'owner' before unlocking anyone
-	// so new and unlocked threads don't park incorrectly.
-	// This may require additional fencing on ARM.
-	this.owner = 0p;
-
-	return V(this.sem);
-}
-
-static inline size_t on_wait( fast_lock & this ) { unlock(this); return 0; }
-static inline void on_wakeup( fast_lock & this, size_t ) { lock(this); }
-static inline void on_notify( fast_lock &, struct thread$ * t ) { unpark(t); }
 
 struct mcs_node {
Index: sts/concurrent/.expect/semaphore.txt
===================================================================
--- tests/concurrent/.expect/semaphore.txt	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ 	(revision )
@@ -1,3 +1,0 @@
-Starting
-Done!
-Match!
Index: sts/concurrent/.expect/spinaphore.txt
===================================================================
--- tests/concurrent/.expect/spinaphore.txt	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ 	(revision )
@@ -1,3 +1,0 @@
-Starting
-Done!
-Match!
Index: sts/concurrent/semaphore.cfa
===================================================================
--- tests/concurrent/semaphore.cfa	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ 	(revision )
@@ -1,78 +1,0 @@
-#include <fstream.hfa>
-#include <locks.hfa>
-#include <thread.hfa>
-#include <mutex_stmt.hfa>
-
-enum { num_blockers = 17, num_unblockers = 13 };
-
-void thrash() {
-	unsigned t[100];
-	for(i; 100) {
-		t[i] = 0xDEADBEEF;
-	}
-}
-
-ThreadBenaphore ben;
-
-// const unsigned int num_blocks = 25000;
-const unsigned int num_blocks = 5;
-
-thread Blocker {
-	size_t sum;
-};
-
-void main(Blocker & this) {
-	thread$ * me = active_thread();
-	this.sum = 0;
-	for(num_blocks) {
-		this.sum += (unsigned)me;
-		thrash();
-		P(ben);
-		if(((thread&)this).seqable.next != 0p) mutex(sout) sout | "Link not invalidated";
-		thrash();
-	}
-}
-
-thread Unblocker {
-	size_t sum;
-};
-
-void main(Unblocker & this) {
-	this.sum = 0;
-	LOOP: for() {
-		waitfor( ^?{} : this) {
-			break LOOP;
-		}
-		or else {}
-
-		thread$ * t = V(ben, false);
-		if(t) {
-			this.sum += (unsigned)t;
-			unpark(t);
-		}
-		yield(random(10));
-	}
-}
-
-int main() {
-	size_t usum = 0;
-	size_t bsum = 0;
-
-	sout | "Starting";
-	{
-		Blocker   blockers  [num_blockers  ];
-		Unblocker unblockers[num_unblockers];
-
-		for(i;num_blockers) {
-			bsum += join(blockers[i]).sum;
-		}
-
-		sout | "Done!";
-
-		for(i;num_unblockers) {
-			usum += join(unblockers[i]).sum;
-		}
-	}
-	if(bsum == usum) sout | "Match!";
-	else sout | "No Match!" | usum | "!=" | bsum;
-}
Index: sts/concurrent/spinaphore.cfa
===================================================================
--- tests/concurrent/spinaphore.cfa	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ 	(revision )
@@ -1,94 +1,0 @@
-#include <fstream.hfa>
-#include <locks.hfa>
-#include <thread.hfa>
-
-enum { num_blockers = 17, num_unblockers = 13 };
-
-void thrash() {
-	unsigned t[100];
-	for(i; 100) {
-		t[i] = 0xDEADBEEF;
-	}
-}
-
-Semaphore0nary sem;
-
-const unsigned int num_blocks = 1625;
-
-thread Blocker {
-	size_t sum;
-};
-void main(Blocker & this);
-
-Blocker * from_thread(thread$ * t) {
-	Blocker & nullb = *(Blocker*)0p;
-	thread$ & nullt = (thread&)nullb;
-	uintptr_t offset  = (uintptr_t)&nullt;
-	uintptr_t address = ((uintptr_t)t) - offset;
-	return (Blocker*)address;
-}
-
-void main(Blocker & this) {
-	thread$ * me = active_thread();
-	Blocker * me1 = &this;
-	Blocker * me2 = from_thread(me);
-	if( me1 != me2 ) sout | "Bad casting!" | me1 | "vs" | me2;
-	this.sum = 0;
-	for(num_blocks) {
-		P(sem);
-		if(((thread&)this).seqable.next != 0p) sout | "Link not invalidated";
-	}
-}
-
-const unsigned int num_unblocks = 2125;
-
-thread Unblocker {
-	size_t sum;
-};
-
-void main(Unblocker & this) {
-	this.sum = 0;
-	unsigned me = (unsigned)(uintptr_t)&this;
-	for(num_unblocks) {
-		thread$ * t = V(sem, false);
-		Blocker * b = from_thread(t);
-		b->sum += me;
-		this.sum += (unsigned)(uintptr_t)b;
-		unpark(t);
-		yield(random(10));
-	}
-}
-
-int main() {
-	size_t usum = 0;
-	size_t bsum = 0;
-
-	if((num_unblocks * num_unblockers) != (num_blocks * num_blockers)) sout | "Mismatched Operations: " | (num_unblocks * num_unblockers) | "vs" | (num_blocks * num_blockers);
-
-	sout | "Starting";
-	{
-		Blocker   blockers  [num_blockers  ];
-		Unblocker unblockers[num_unblockers];
-
-		for(i;num_blockers) {
-			for(num_blocks)
-				usum += (unsigned)(uintptr_t)&blockers[i];
-		}
-
-		for(i;num_unblockers) {
-			for(num_unblocks)
-				bsum += (unsigned)(uintptr_t)&unblockers[i];
-		}
-
-		for(i;num_blockers) {
-			bsum -= join(blockers[i]).sum;
-		}
-
-		for(i;num_unblockers) {
-			usum -= join(unblockers[i]).sum;
-		}
-	}
-	sout | "Done!";
-	if(bsum == 0 && usum == 0) sout | "Match!";
-	else sout | "No Match!" | usum | "/" | bsum;
-}
Index: tests/unified_locking/.expect/locks.txt
===================================================================
--- tests/unified_locking/.expect/locks.txt	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ tests/unified_locking/.expect/locks.txt	(revision 0fc447c38ee7b02d6cdb7bd08aef617ade5852c7)
@@ -11,18 +11,14 @@
 Start Test 6: owner lock and condition variable 3 wait/notify all
 Done Test 6
-Start Test 7: fast lock and condition variable single wait/notify
+Start Test 7: linear backoff lock and condition variable single wait/notify
 Done Test 7
-Start Test 8: fast lock and condition variable 3 wait/notify all
+Start Test 8: linear backoff lock and condition variable 3 wait/notify all
 Done Test 8
-Start Test 9: linear backoff lock and condition variable single wait/notify
+Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify
 Done Test 9
-Start Test 10: linear backoff lock and condition variable 3 wait/notify all
+Start Test 10: owner lock and condition variable multiple acquire and wait/notify
 Done Test 10
-Start Test 11: multi acquisiton lock and condition variable multiple acquire and wait/notify
+Start Test 11: no lock condition variable wait/notify
 Done Test 11
-Start Test 12: owner lock and condition variable multiple acquire and wait/notify
+Start Test 12: locked condition variable wait/notify with front()
 Done Test 12
-Start Test 13: no lock condition variable wait/notify
-Done Test 13
-Start Test 14: locked condition variable wait/notify with front()
-Done Test 14
Index: tests/unified_locking/locks.cfa
===================================================================
--- tests/unified_locking/locks.cfa	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ tests/unified_locking/locks.cfa	(revision 0fc447c38ee7b02d6cdb7bd08aef617ade5852c7)
@@ -15,7 +15,4 @@
 condition_variable( owner_lock ) c_o;
 
-fast_lock f;
-condition_variable( fast_lock ) c_f;
-
 linear_backoff_then_block_lock l;
 condition_variable( linear_backoff_then_block_lock ) c_l;
@@ -74,32 +71,4 @@
 		}
 		unlock(s);
-	}
-}
-
-thread T_C_F_WS1 {};
-
-void main( T_C_F_WS1 & this ) {
-	for (unsigned int i = 0; i < num_times; i++) {
-		lock(f);
-		if(empty(c_f) && i != num_times - 1) {
-			wait(c_f,f);
-		}else{
-			notify_one(c_f);
-		}
-		unlock(f);
-	}
-}
-
-thread T_C_F_WB1 {};
-
-void main( T_C_F_WB1 & this ) {
-	for (unsigned int i = 0; i < num_times; i++) {
-		lock(f);
-		if(counter(c_f) == 3 || i == num_times - 1) {
-			notify_all(c_f);
-		}else{
-			wait(c_f,f);
-		}
-		unlock(f);
 	}
 }
@@ -317,51 +286,39 @@
 	printf("Done Test 6\n");
 
-	printf("Start Test 7: fast lock and condition variable single wait/notify\n");
-	{
-		T_C_F_WS1 t1[2];
+	printf("Start Test 7: linear backoff lock and condition variable single wait/notify\n");
+	{
+		T_C_L_WS1 t1[2];
 	}
 	printf("Done Test 7\n");
 
-	printf("Start Test 8: fast lock and condition variable 3 wait/notify all\n");
-	{
-		T_C_F_WB1 t1[4];
+	printf("Start Test 8: linear backoff lock and condition variable 3 wait/notify all\n");
+	{
+		T_C_L_WB1 t1[4];
 	}
 	printf("Done Test 8\n");
 
-	printf("Start Test 9: linear backoff lock and condition variable single wait/notify\n");
-	{
-		T_C_L_WS1 t1[2];
+	printf("Start Test 9: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
+	{
+		T_C_M_WS2 t1[2];
 	}
 	printf("Done Test 9\n");
 
-	printf("Start Test 10: linear backoff lock and condition variable 3 wait/notify all\n");
-	{
-		T_C_L_WB1 t1[4];
+	printf("Start Test 10: owner lock and condition variable multiple acquire and wait/notify\n");
+	{
+		T_C_O_WS2 t1[2];
 	}
 	printf("Done Test 10\n");
 
-	printf("Start Test 11: multi acquisiton lock and condition variable multiple acquire and wait/notify\n");
-	{
-		T_C_M_WS2 t1[2];
-	}
-	printf("Done Test 11\n");
-
-	printf("Start Test 12: owner lock and condition variable multiple acquire and wait/notify\n");
-	{
-		T_C_O_WS2 t1[2];
-	}
-	printf("Done Test 12\n");
-
-	printf("Start Test 13: no lock condition variable wait/notify\n");
+	printf("Start Test 11: no lock condition variable wait/notify\n");
 	{
 		T_C_NLW t1;
 		T_C_NLS t2;
 	}
-	printf("Done Test 13\n");
-
-	printf("Start Test 14: locked condition variable wait/notify with front()\n");
+	printf("Done Test 11\n");
+
+	printf("Start Test 12: locked condition variable wait/notify with front()\n");
 	{
 		T_C_S_WNF t1[2];
 	}
-	printf("Done Test 14\n");
-}
+	printf("Done Test 12\n");
+}
Index: sts/zombies/fastlock.cfa
===================================================================
--- tests/zombies/fastlock.cfa	(revision a2a45661d68494461a3f2023e6bb1f882c424ac1)
+++ 	(revision )
@@ -1,8 +1,0 @@
-#include <locks.hfa>
-
-#define LOCK fast_lock
-#include "mutex_test.hfa"
-
-int main() {
-    test();
-}