Index: benchmark/io/http/main.cfa
===================================================================
--- benchmark/io/http/main.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ benchmark/io/http/main.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -125,5 +125,5 @@
 						workers[i].flags   = 0;
 					}
-					unpark( workers[i] __cfaabi_dbg_ctx2 );
+					unpark( workers[i] );
 				}
 				printf("%d workers started on %d processors\n", options.clopts.nworkers, options.clopts.nprocs);
Index: benchmark/io/http/worker.cfa
===================================================================
--- benchmark/io/http/worker.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ benchmark/io/http/worker.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -22,5 +22,5 @@
 
 void main( Worker & this ) {
-	park( __cfaabi_dbg_ctx );
+	park();
 	/* paranoid */ assert( this.pipe[0] != -1 );
 	/* paranoid */ assert( this.pipe[1] != -1 );
Index: benchmark/io/readv.cfa
===================================================================
--- benchmark/io/readv.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ benchmark/io/readv.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -54,5 +54,5 @@
 
 void main( Reader & ) {
-	park( __cfaabi_dbg_ctx );
+	park();
 	/* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
 
@@ -151,5 +151,5 @@
 
 				for(i; nthreads) {
-					unpark( threads[i] __cfaabi_dbg_ctx2 );
+					unpark( threads[i] );
 				}
 				wait(duration, start, end, is_tty);
Index: benchmark/readyQ/yield.cfa
===================================================================
--- benchmark/readyQ/yield.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ benchmark/readyQ/yield.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -32,5 +32,5 @@
 
 void main( Yielder & this ) {
-	park( __cfaabi_dbg_ctx );
+	park();
 	/* paranoid */ assert( true == __atomic_load_n(&run, __ATOMIC_RELAXED) );
 
@@ -70,5 +70,5 @@
 
 				for(i; nthreads) {
-					unpark( threads[i] __cfaabi_dbg_ctx2 );
+					unpark( threads[i] );
 				}
 				wait(duration, start, end, is_tty);
Index: libcfa/src/bits/locks.hfa
===================================================================
--- libcfa/src/bits/locks.hfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/bits/locks.hfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -164,6 +164,6 @@
 
 	struct $thread;
-	extern void park( __cfaabi_dbg_ctx_param );
-	extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 );
+	extern void park( void );
+	extern void unpark( struct $thread * this );
 	static inline struct $thread * active_thread ();
 
@@ -191,5 +191,5 @@
 					/* paranoid */ verify( expected == 0p );
 					if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-						park( __cfaabi_dbg_ctx );
+						park();
 						return true;
 					}
@@ -210,5 +210,5 @@
 				else {
 					if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-						unpark( expected __cfaabi_dbg_ctx2 );
+						unpark( expected );
 						return true;
 					}
@@ -244,5 +244,5 @@
 				/* paranoid */ verify( expected == 0p );
 				if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-					park( __cfaabi_dbg_ctx );
+					park();
 					/* paranoid */ verify( this.ptr == 1p );
 					return true;
@@ -256,5 +256,5 @@
 			struct $thread * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
 			if( got == 0p ) return false;
-			unpark( got __cfaabi_dbg_ctx2 );
+			unpark( got );
 			return true;
 		}
Index: libcfa/src/concurrency/alarm.cfa
===================================================================
--- libcfa/src/concurrency/alarm.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/alarm.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -130,5 +130,5 @@
 
 	register_self( &node );
-	park( __cfaabi_dbg_ctx );
+	park();
 
 	/* paranoid */ verify( !node.set );
Index: libcfa/src/concurrency/clib/cfathread.cfa
===================================================================
--- libcfa/src/concurrency/clib/cfathread.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/clib/cfathread.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -44,9 +44,9 @@
 
 	void cfathread_park( void ) {
-		park( __cfaabi_dbg_ctx );
+		park();
 	}
 
 	void cfathread_unpark( CRunner * thrd ) {
-		unpark( *thrd __cfaabi_dbg_ctx2 );
+		unpark( *thrd );
 	}
 
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/invoke.h	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -94,5 +94,5 @@
 	};
 	// Wrapper for gdb
-	struct cfathread_coroutine_t { $coroutine debug; };
+	struct cfathread_coroutine_t { struct $coroutine debug; };
 
 	static inline struct __stack_t * __get_stack( struct $coroutine * cor ) {
@@ -132,5 +132,5 @@
 	};
 	// Wrapper for gdb
-	struct cfathread_monitor_t { $monitor debug; };
+	struct cfathread_monitor_t { struct $monitor debug; };
 
 	struct __monitor_group_t {
@@ -191,17 +191,9 @@
 
 		#ifdef __CFA_DEBUG__
-			// previous function to park/unpark the thread
-			const char * park_caller;
-			int park_result;
-			enum __Coroutine_State park_state;
-			bool park_stale;
-			const char * unpark_caller;
-			int unpark_result;
-			enum __Coroutine_State unpark_state;
-			bool unpark_stale;
+			unsigned long long canary;
 		#endif
 	};
 	// Wrapper for gdb
-	struct cfathread_thread_t { $thread debug; };
+	struct cfathread_thread_t { struct $thread debug; };
 
 	#ifdef __CFA_DEBUG__
Index: libcfa/src/concurrency/io.cfa
===================================================================
--- libcfa/src/concurrency/io.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/io.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -69,5 +69,5 @@
 		if( block ) {
 			enable_interrupts( __cfaabi_dbg_ctx );
-			park( __cfaabi_dbg_ctx );
+			park();
 			disable_interrupts();
 		}
Index: libcfa/src/concurrency/io/setup.cfa
===================================================================
--- libcfa/src/concurrency/io/setup.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/io/setup.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -247,5 +247,4 @@
 					thrd.link.next = 0p;
 					thrd.link.prev = 0p;
-					__cfaabi_dbg_debug_do( thrd.unpark_stale = true );
 
 					// Fixup the thread state
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/kernel.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -246,8 +246,4 @@
 		thrd_dst->state = Active;
 
-		__cfaabi_dbg_debug_do(
-			thrd_dst->park_stale   = true;
-			thrd_dst->unpark_stale = true;
-		)
 		// Update global state
 		kernelTLS.this_thread = thrd_dst;
@@ -288,5 +284,5 @@
 			// The thread has halted, it should never be scheduled/run again
 			// We may need to wake someone up here since
-			unpark( this->destroyer __cfaabi_dbg_ctx2 );
+			unpark( this->destroyer );
 			this->destroyer = 0p;
 			break RUNNING;
@@ -298,5 +294,4 @@
 		// set state of processor coroutine to active and the thread to inactive
 		int old_ticket = __atomic_fetch_sub(&thrd_dst->ticket, 1, __ATOMIC_SEQ_CST);
-		__cfaabi_dbg_debug_do( thrd_dst->park_result = old_ticket; )
 		switch(old_ticket) {
 			case 1:
@@ -404,10 +399,6 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark(  struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
-	// record activity
-	__cfaabi_dbg_record_thrd( *thrd, false, caller );
-
+void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
 	int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
-	__cfaabi_dbg_debug_do( thrd->unpark_result = old_ticket; thrd->unpark_state = thrd->state; )
 	switch(old_ticket) {
 		case 1:
@@ -427,20 +418,17 @@
 }
 
-void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+void unpark( $thread * thrd ) {
 	if( !thrd ) return;
 
 	disable_interrupts();
-	__unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 );
+	__unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
 	enable_interrupts( __cfaabi_dbg_ctx );
 }
 
-void park( __cfaabi_dbg_ctx_param ) {
+void park( void ) {
 	/* paranoid */ verify( kernelTLS.preemption_state.enabled );
 	disable_interrupts();
 	/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 	/* paranoid */ verify( kernelTLS.this_thread->preempted == __NO_PREEMPTION );
-
-	// record activity
-	__cfaabi_dbg_record_thrd( *kernelTLS.this_thread, true, caller );
 
 	returnToKernel();
@@ -650,5 +638,5 @@
 		// atomically release spin lock and block
 		unlock( lock );
-		park( __cfaabi_dbg_ctx );
+		park();
 		return true;
 	}
@@ -671,5 +659,5 @@
 
 	// make new owner
-	unpark( thrd __cfaabi_dbg_ctx2 );
+	unpark( thrd );
 
 	return thrd != 0p;
@@ -682,5 +670,5 @@
 	count += diff;
 	for(release) {
-		unpark( pop_head( waiting ) __cfaabi_dbg_ctx2 );
+		unpark( pop_head( waiting ) );
 	}
 
@@ -698,15 +686,4 @@
 			this.prev_thrd = kernelTLS.this_thread;
 		}
-
-		void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
-			if(park) {
-				this.park_caller   = prev_name;
-				this.park_stale    = false;
-			}
-			else {
-				this.unpark_caller = prev_name;
-				this.unpark_stale  = false;
-			}
-		}
 	}
 )
Index: libcfa/src/concurrency/kernel/fwd.hfa
===================================================================
--- libcfa/src/concurrency/kernel/fwd.hfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/kernel/fwd.hfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -118,6 +118,6 @@
 
 	extern "Cforall" {
-		extern void park( __cfaabi_dbg_ctx_param );
-		extern void unpark( struct $thread * this __cfaabi_dbg_ctx_param2 );
+		extern void park( void );
+		extern void unpark( struct $thread * this );
 		static inline struct $thread * active_thread () { return TL_GET( this_thread ); }
 
Index: libcfa/src/concurrency/kernel_private.hfa
===================================================================
--- libcfa/src/concurrency/kernel_private.hfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/kernel_private.hfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -64,5 +64,5 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark( struct __processor_id_t *, $thread * thrd __cfaabi_dbg_ctx_param2 );
+void __unpark( struct __processor_id_t *, $thread * thrd );
 
 static inline bool __post(single_sem & this, struct __processor_id_t * id) {
@@ -77,5 +77,5 @@
 		else {
 			if(__atomic_compare_exchange_n(&this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
-				__unpark( id, expected __cfaabi_dbg_ctx2 );
+				__unpark( id, expected );
 				return true;
 			}
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/monitor.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -122,5 +122,5 @@
 
 		unlock( this->lock );
-		park( __cfaabi_dbg_ctx );
+		park();
 
 		__cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
@@ -201,8 +201,8 @@
 		// Release the next thread
 		/* paranoid */ verifyf( urgent->owner->waiting_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
-		unpark( urgent->owner->waiting_thread __cfaabi_dbg_ctx2 );
+		unpark( urgent->owner->waiting_thread );
 
 		// Park current thread waiting
-		park( __cfaabi_dbg_ctx );
+		park();
 
 		// Some one was waiting for us, enter
@@ -222,5 +222,5 @@
 
 		// Park current thread waiting
-		park( __cfaabi_dbg_ctx );
+		park();
 
 		/* paranoid */ verifyf( kernelTLS.this_thread == this->owner, "Expected owner to be %p, got %p (r: %i, m: %p)", kernelTLS.this_thread, this->owner, this->recursion, this );
@@ -264,5 +264,5 @@
 	//We need to wake-up the thread
 	/* paranoid */ verifyf( !new_owner || new_owner == this->owner, "Expected owner to be %p, got %p (m: %p)", new_owner, this->owner, this );
-	unpark( new_owner __cfaabi_dbg_ctx2 );
+	unpark( new_owner );
 }
 
@@ -493,9 +493,9 @@
 	// Wake the threads
 	for(int i = 0; i < thread_count; i++) {
-		unpark( threads[i] __cfaabi_dbg_ctx2 );
+		unpark( threads[i] );
 	}
 
 	// Everything is ready to go to sleep
-	park( __cfaabi_dbg_ctx );
+	park();
 
 	// We are back, restore the owners and recursions
@@ -575,8 +575,8 @@
 
 	// unpark the thread we signalled
-	unpark( signallee __cfaabi_dbg_ctx2 );
+	unpark( signallee );
 
 	//Everything is ready to go to sleep
-	park( __cfaabi_dbg_ctx );
+	park();
 
 
@@ -679,8 +679,8 @@
 
 				// unpark the thread we signalled
-				unpark( next __cfaabi_dbg_ctx2 );
+				unpark( next );
 
 				//Everything is ready to go to sleep
-				park( __cfaabi_dbg_ctx );
+				park();
 
 				// We are back, restore the owners and recursions
@@ -724,5 +724,5 @@
 
 	//Everything is ready to go to sleep
-	park( __cfaabi_dbg_ctx );
+	park();
 
 
Index: libcfa/src/concurrency/mutex.cfa
===================================================================
--- libcfa/src/concurrency/mutex.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/mutex.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -42,5 +42,5 @@
 		append( blocked_threads, kernelTLS.this_thread );
 		unlock( lock );
-		park( __cfaabi_dbg_ctx );
+		park();
 	}
 	else {
@@ -65,5 +65,5 @@
 	this.is_locked = (this.blocked_threads != 0);
 	unpark(
-		pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+		pop_head( this.blocked_threads )
 	);
 	unlock( this.lock );
@@ -97,5 +97,5 @@
 		append( blocked_threads, kernelTLS.this_thread );
 		unlock( lock );
-		park( __cfaabi_dbg_ctx );
+		park();
 	}
 }
@@ -124,5 +124,5 @@
 		owner = thrd;
 		recursion_count = (thrd ? 1 : 0);
-		unpark( thrd __cfaabi_dbg_ctx2 );
+		unpark( thrd );
 	}
 	unlock( lock );
@@ -142,5 +142,5 @@
 	lock( lock __cfaabi_dbg_ctx2 );
 	unpark(
-		pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+		pop_head( this.blocked_threads )
 	);
 	unlock( lock );
@@ -151,5 +151,5 @@
 	while(this.blocked_threads) {
 		unpark(
-			pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
+			pop_head( this.blocked_threads )
 		);
 	}
@@ -161,5 +161,5 @@
 	append( this.blocked_threads, kernelTLS.this_thread );
 	unlock( this.lock );
-	park( __cfaabi_dbg_ctx );
+	park();
 }
 
@@ -170,5 +170,5 @@
 	unlock(l);
 	unlock(this.lock);
-	park( __cfaabi_dbg_ctx );
+	park();
 	lock(l);
 }
Index: libcfa/src/concurrency/preemption.cfa
===================================================================
--- libcfa/src/concurrency/preemption.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/preemption.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -274,5 +274,5 @@
 		kernelTLS.this_stats = this->curr_cluster->stats;
 	#endif
-	__unpark( id, this __cfaabi_dbg_ctx2 );
+	__unpark( id, this );
 }
 
Index: libcfa/src/concurrency/thread.hfa
===================================================================
--- libcfa/src/concurrency/thread.hfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ libcfa/src/concurrency/thread.hfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -88,13 +88,13 @@
 //----------
 // Park thread: block until corresponding call to unpark, won't block if unpark is already called
-void park( __cfaabi_dbg_ctx_param );
+void park( void );
 
 //----------
 // Unpark a thread, if the thread is already blocked, schedule it
 //                  if the thread is not yet block, signal that it should rerun immediately
-void unpark( $thread * this __cfaabi_dbg_ctx_param2 );
+void unpark( $thread * this );
 
 forall( dtype T | is_thread(T) )
-static inline void unpark( T & this __cfaabi_dbg_ctx_param2 ) { if(!&this) return; unpark( get_thread( this ) __cfaabi_dbg_ctx_fwd2 );}
+static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
 
 //----------
Index: tests/concurrent/park/contention.cfa
===================================================================
--- tests/concurrent/park/contention.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ tests/concurrent/park/contention.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -21,9 +21,9 @@
 		if(blocked[idx]) {
 			Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST);
-			unpark( *thrd __cfaabi_dbg_ctx2 );
+			unpark( *thrd );
 		} else {
 			Thread * thrd = __atomic_exchange_n(&blocked[idx], &this, __ATOMIC_SEQ_CST);
-			unpark( *thrd __cfaabi_dbg_ctx2 );
-			park( __cfaabi_dbg_ctx );
+			unpark( *thrd );
+			park();
 		}
 	}
@@ -41,5 +41,5 @@
 			int idx = myrand() % blocked_size;
 			Thread * thrd = __atomic_exchange_n(&blocked[idx], 0p, __ATOMIC_SEQ_CST);
-			unpark( *thrd __cfaabi_dbg_ctx2 );
+			unpark( *thrd );
 			yield( myrand() % 20 );
 		}
Index: tests/concurrent/park/force_preempt.cfa
===================================================================
--- tests/concurrent/park/force_preempt.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ tests/concurrent/park/force_preempt.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -30,5 +30,5 @@
 
 		// Unpark this thread, don't force a yield
-		unpark( this __cfaabi_dbg_ctx2 );
+		unpark( this );
 		assert(mask == 0xCAFEBABA);
 
@@ -43,5 +43,5 @@
 		// Park this thread,
 		assert(mask == (id_hash ^ 0xCAFEBABA));
-		park( __cfaabi_dbg_ctx );
+		park();
 		assert(mask == (id_hash ^ 0xCAFEBABA));
 
Index: tests/concurrent/park/start_parked.cfa
===================================================================
--- tests/concurrent/park/start_parked.cfa	(revision 038110a589408bf46d4605add1b1379fca5d94af)
+++ tests/concurrent/park/start_parked.cfa	(revision e23542987c42024e758269c7930ff52bdaf97f78)
@@ -3,5 +3,5 @@
 thread Parker {};
 void main( Parker & ) {
-	park( __cfaabi_dbg_ctx );
+	park();
 }
 
@@ -9,5 +9,5 @@
 	for(1000) {
 		Parker parker;
-		unpark( parker __cfaabi_dbg_ctx2 );
+		unpark( parker );
 	}
 	printf( "done\n" );									// non-empty .expect file
