Index: libcfa/src/concurrency/locks.cfa
===================================================================
--- libcfa/src/concurrency/locks.cfa	(revision 433905a9e171762b3a0680e099a6479705f8f04a)
+++ libcfa/src/concurrency/locks.cfa	(revision ec57856c471d68c27156f9fbc24b955edafbcb9a)
@@ -220,7 +220,9 @@
 
 //-----------------------------------------------------------------------------
-// condition variable
+// Synchronization Locks
 forall(L & | is_blocking_lock(L)) {
 
+	//-----------------------------------------------------------------------------
+	// condition variable
 	void ?{}( condition_variable(L) & this ){
 		this.lock{};
@@ -337,4 +339,51 @@
 	bool wait( condition_variable(L) & this, L & l, Duration duration                 ) with(this) { WAIT_TIME( 0   , &l , duration ) }
 	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , duration ) }
+
+	//-----------------------------------------------------------------------------
+	// fast_cond_var
+	void  ?{}( fast_cond_var(L) & this ){
+		this.blocked_threads{}; 
+		#ifdef __CFA_DEBUG__
+		this.lock_used = 0p;
+		#endif
+	}
+	void ^?{}( fast_cond_var(L) & this ){ }
+
+	bool notify_one( fast_cond_var(L) & this ) with(this) {
+		bool ret = ! blocked_threads`isEmpty;
+		if ( ret ) {
+			info_thread(L) & popped = try_pop_front( blocked_threads );
+			on_notify(*popped.lock, popped.t);
+		}
+		return ret;
+	}
+	bool notify_all( fast_cond_var(L) & this ) with(this) {
+		bool ret = ! blocked_threads`isEmpty;
+		while( ! blocked_threads`isEmpty ) {
+			info_thread(L) & popped = try_pop_front( blocked_threads );
+			on_notify(*popped.lock, popped.t);
+		}
+		return ret;
+	}
+
+	uintptr_t front( fast_cond_var(L) & this ) with(this) { return blocked_threads`isEmpty ? NULL : blocked_threads`first.info; }
+	bool empty ( fast_cond_var(L) & this ) with(this) { return blocked_threads`isEmpty; }
+
+	void wait( fast_cond_var(L) & this, L & l ) {
+		wait( this, l, 0 );
+	}
+
+	void wait( fast_cond_var(L) & this, L & l, uintptr_t info ) with(this) {
+		// brand cond lock with lock
+		#ifdef __CFA_DEBUG__
+			if ( lock_used == 0p ) lock_used = &l;
+			else { assert(lock_used == &l); }
+		#endif
+		info_thread( L ) i = { active_thread(), info, &l };
+		insert_last( blocked_threads, i );
+		size_t recursion_count = on_wait( *i.lock );
+		park( );
+		on_wakeup(*i.lock, recursion_count);
+	}
 }
 
Index: libcfa/src/concurrency/locks.hfa
===================================================================
--- libcfa/src/concurrency/locks.hfa	(revision 433905a9e171762b3a0680e099a6479705f8f04a)
+++ libcfa/src/concurrency/locks.hfa	(revision ec57856c471d68c27156f9fbc24b955edafbcb9a)
@@ -73,4 +73,6 @@
 static inline void   on_notify( owner_lock & this, struct thread$ * t ) { on_notify( (blocking_lock &)this, t ); }
 
+//-----------------------------------------------------------------------------
+// MCS Lock
 struct mcs_node {
 	mcs_node * volatile next;
@@ -98,4 +100,6 @@
 }
 
+//-----------------------------------------------------------------------------
+// Linear backoff Spinlock
 struct linear_backoff_then_block_lock {
 	// Spin lock used for mutual exclusion
@@ -199,4 +203,56 @@
 
 //-----------------------------------------------------------------------------
+// Fast Block Lock
+
+// High efficiency minimal blocking lock
+// - No reacquire for cond var
+// - No recursive acquisition
+// - No ownership
+struct fast_block_lock {
+	// Spin lock used for mutual exclusion
+	__spinlock_t lock;
+
+	// List of blocked threads
+	dlist( thread$ ) blocked_threads;
+
+	bool held:1;
+};
+
+static inline void  ?{}( fast_block_lock & this ) with(this) {
+	lock{};
+	blocked_threads{};
+	held = false;
+}
+static inline void ^?{}( fast_block_lock & this ) {}
+static inline void ?{}( fast_block_lock & this, fast_block_lock this2 ) = void;
+static inline void ?=?( fast_block_lock & this, fast_block_lock this2 ) = void;
+
+// if this is called recursively IT WILL DEADLOCK!!!!!
+static inline void lock(fast_block_lock & this) with(this) {
+	lock( lock __cfaabi_dbg_ctx2 );
+	if (held) {
+		insert_last( blocked_threads, *active_thread() );
+		unlock( lock );
+		park( );
+		return;
+	}
+	held = true;
+	unlock( lock );
+}
+
+static inline void unlock(fast_block_lock & this) with(this) {
+	lock( lock __cfaabi_dbg_ctx2 );
+	/* paranoid */ verifyf( held != false, "Attempt to release lock %p that isn't held", &this );
+	thread$ * t = &try_pop_front( blocked_threads );
+	held = ( t ? true : false );
+	unpark( t );
+	unlock( lock );
+}
+
+static inline void on_notify(fast_block_lock & this, struct thread$ * t ) { unpark(t); }
+static inline size_t on_wait(fast_block_lock & this) { unlock(this); return 0; }
+static inline void on_wakeup(fast_block_lock & this, size_t recursion ) { }
+
+//-----------------------------------------------------------------------------
 // is_blocking_lock
 trait is_blocking_lock(L & | sized(L)) {
@@ -226,4 +282,14 @@
 // Synchronization Locks
 forall(L & | is_blocking_lock(L)) {
+
+	//-----------------------------------------------------------------------------
+	// condition_variable
+
+	// The multi-tool condition variable
+	// - can pass timeouts to wait for either a signal or timeout
+	// - can wait without passing a lock
+	// - can have waiters reacquire different locks while waiting on the same cond var
+	// - has shadow queue
+	// - can be signalled outside of critical sections with no locks held
 	struct condition_variable {
 		// Spin lock used for mutual exclusion
@@ -258,3 +324,33 @@
 	bool wait( condition_variable(L) & this, L & l, Duration duration );
 	bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
-}
+
+	//-----------------------------------------------------------------------------
+	// fast_cond_var
+
+	// The trimmed and slim condition variable
+	// - no internal lock so you must hold a lock while using this cond var
+	// - signalling without holding branded lock is UNSAFE!
+	// - only allows usage of one lock, cond var is branded after usage
+	struct fast_cond_var {
+		// List of blocked threads
+		dlist( info_thread(L) ) blocked_threads;
+
+		#ifdef __CFA_DEBUG__
+		L * lock_used;
+		#endif
+	};
+
+
+	void  ?{}( fast_cond_var(L) & this );
+	void ^?{}( fast_cond_var(L) & this );
+
+	bool notify_one( fast_cond_var(L) & this );
+	bool notify_all( fast_cond_var(L) & this );
+
+	uintptr_t front( fast_cond_var(L) & this );
+
+	bool empty  ( fast_cond_var(L) & this );
+
+	void wait( fast_cond_var(L) & this, L & l );
+	void wait( fast_cond_var(L) & this, L & l, uintptr_t info );
+}