Index: libcfa/src/bits/debug.hfa
===================================================================
--- libcfa/src/bits/debug.hfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/bits/debug.hfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -23,4 +23,6 @@
 	#define __cfaabi_dbg_ctx_param const char caller[]
 	#define __cfaabi_dbg_ctx_param2 , const char caller[]
+	#define __cfaabi_dbg_ctx_fwd caller
+	#define __cfaabi_dbg_ctx_fwd2 , caller
 #else
 	#define __cfaabi_dbg_debug_do(...)
@@ -30,4 +32,6 @@
 	#define __cfaabi_dbg_ctx_param
 	#define __cfaabi_dbg_ctx_param2
+	#define __cfaabi_dbg_ctx_fwd
+	#define __cfaabi_dbg_ctx_fwd2
 #endif
 
Index: libcfa/src/bits/locks.hfa
===================================================================
--- libcfa/src/bits/locks.hfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/bits/locks.hfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -54,7 +54,7 @@
 
 		#ifdef __CFA_DEBUG__
-			void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]);
+			void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]);
 		#else
-			#define __cfaabi_dbg_record(x, y)
+			#define __cfaabi_dbg_record_lock(x, y)
 		#endif
 	}
@@ -69,5 +69,5 @@
 		bool result = (this.lock == 0) && (__atomic_test_and_set( &this.lock, __ATOMIC_ACQUIRE ) == 0);
 		if( result ) {
-			__cfaabi_dbg_record( this, caller );
+			__cfaabi_dbg_record_lock( this, caller );
 		} else {
 			enable_interrupts_noPoll();
@@ -99,5 +99,5 @@
 			#endif
 		}
-		__cfaabi_dbg_record( this, caller );
+		__cfaabi_dbg_record_lock( this, caller );
 	}
 
Index: libcfa/src/concurrency/invoke.h
===================================================================
--- libcfa/src/concurrency/invoke.h	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/concurrency/invoke.h	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -198,5 +198,19 @@
 			struct $thread * prev;
 		} node;
-	};
+
+		#ifdef __CFA_DEBUG__
+			// previous function to park/unpark the thread
+			const char * prev_park;
+			bool park_stale;
+			const char * prev_unpark;
+			bool unpark_stale;
+		#endif
+	};
+
+	#ifdef __CFA_DEBUG__
+		void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]);
+	#else
+		#define __cfaabi_dbg_record_thrd(x, y, z)
+	#endif
 
 	#ifdef __cforall
Index: libcfa/src/concurrency/kernel.cfa
===================================================================
--- libcfa/src/concurrency/kernel.cfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/concurrency/kernel.cfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -343,4 +343,9 @@
 		}
 
+		__cfaabi_dbg_debug_do(
+			thrd_dst->park_stale = true;
+			thrd_dst->park_stale = false;
+		)
+
 		/* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 		/* paranoid */ verifyf( ((uintptr_t)thrd_dst->context.SP) < ((uintptr_t)__get_stack(thrd_dst->curr_cor)->base ) || thrd_dst->curr_cor == proc_cor, "ERROR : Destination $thread %p has been corrupted.\n StackPointer too small.\n", thrd_dst ); // add escape condition if we are setting up the processor
@@ -381,5 +386,5 @@
 
 				// We may need to wake someone up here since
-				unpark( this->destroyer );
+				unpark( this->destroyer __cfaabi_dbg_ctx2 );
 				this->destroyer = 0p;
 				break RUNNING;
@@ -588,9 +593,13 @@
 }
 
-void unpark( $thread * thrd ) {
+void unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
 	if( !thrd ) return;
 
 	disable_interrupts();
 	static_assert(sizeof(thrd->state) == sizeof(int));
+	
+	// record activity
+	__cfaabi_dbg_record_thrd( *thrd, false, caller );
+
 	enum coroutine_state old_state = __atomic_exchange_n(&thrd->state, Rerun, __ATOMIC_SEQ_CST);
 	switch(old_state) {
@@ -618,9 +627,12 @@
 }
 
-void park( void ) {
+void park( __cfaabi_dbg_ctx_param ) {
 	/* 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();
@@ -898,5 +910,5 @@
 		// atomically release spin lock and block
 		unlock( lock );
-		park();
+		park( __cfaabi_dbg_ctx );
 	}
 	else {
@@ -917,5 +929,5 @@
 
 	// make new owner
-	unpark( thrd );
+	unpark( thrd __cfaabi_dbg_ctx2 );
 }
 
@@ -966,7 +978,18 @@
 __cfaabi_dbg_debug_do(
 	extern "C" {
-		void __cfaabi_dbg_record(__spinlock_t & this, const char prev_name[]) {
+		void __cfaabi_dbg_record_lock(__spinlock_t & this, const char prev_name[]) {
 			this.prev_name = prev_name;
 			this.prev_thrd = kernelTLS.this_thread;
+		}
+
+		void __cfaabi_dbg_record_thrd($thread & this, bool park, const char prev_name[]) {
+			if(park) {
+				this.prev_park    = prev_name;
+				this.park_stale   = false;
+			}
+			else {
+				this.prev_unpark  = prev_name;
+				this.unpark_stale = false;
+			}
 		}
 	}
Index: libcfa/src/concurrency/monitor.cfa
===================================================================
--- libcfa/src/concurrency/monitor.cfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/concurrency/monitor.cfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -119,5 +119,5 @@
 
 		unlock( this->lock );
-		park();
+		park( __cfaabi_dbg_ctx );
 
 		__cfaabi_dbg_print_safe( "Kernel : %10p Entered  mon %p\n", thrd, this);
@@ -184,8 +184,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 );
+		unpark( urgent->owner->waiting_thread __cfaabi_dbg_ctx2 );
 
 		// Park current thread waiting
-		park();
+		park( __cfaabi_dbg_ctx );
 
 		// Some one was waiting for us, enter
@@ -205,5 +205,5 @@
 
 		// Park current thread waiting
-		park();
+		park( __cfaabi_dbg_ctx );
 
 		/* 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 );
@@ -247,5 +247,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 );
+	unpark( new_owner __cfaabi_dbg_ctx2 );
 }
 
@@ -460,9 +460,9 @@
 	// Wake the threads
 	for(int i = 0; i < thread_count; i++) {
-		unpark( threads[i] );
+		unpark( threads[i] __cfaabi_dbg_ctx2 );
 	}
 
 	// Everything is ready to go to sleep
-	park();
+	park( __cfaabi_dbg_ctx );
 
 	// We are back, restore the owners and recursions
@@ -542,8 +542,8 @@
 
 	// unpark the thread we signalled
-	unpark( signallee );
+	unpark( signallee __cfaabi_dbg_ctx2 );
 
 	//Everything is ready to go to sleep
-	park();
+	park( __cfaabi_dbg_ctx );
 
 
@@ -646,8 +646,8 @@
 
 				// unpark the thread we signalled
-				unpark( next );
+				unpark( next __cfaabi_dbg_ctx2 );
 
 				//Everything is ready to go to sleep
-				park();
+				park( __cfaabi_dbg_ctx );
 
 				// We are back, restore the owners and recursions
@@ -691,5 +691,5 @@
 
 	//Everything is ready to go to sleep
-	park();
+	park( __cfaabi_dbg_ctx );
 
 
Index: libcfa/src/concurrency/mutex.cfa
===================================================================
--- libcfa/src/concurrency/mutex.cfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/concurrency/mutex.cfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -41,5 +41,5 @@
 		append( blocked_threads, kernelTLS.this_thread );
 		unlock( lock );
-		park();
+		park( __cfaabi_dbg_ctx );
 	}
 	else {
@@ -64,5 +64,5 @@
 	this.is_locked = (this.blocked_threads != 0);
 	unpark(
-		pop_head( this.blocked_threads )
+		pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
 	);
 	unlock( this.lock );
@@ -96,5 +96,5 @@
 		append( blocked_threads, kernelTLS.this_thread );
 		unlock( lock );
-		park();
+		park( __cfaabi_dbg_ctx );
 	}
 }
@@ -123,5 +123,5 @@
 		owner = thrd;
 		recursion_count = (thrd ? 1 : 0);
-		unpark( thrd );
+		unpark( thrd __cfaabi_dbg_ctx2 );
 	}
 	unlock( lock );
@@ -141,5 +141,5 @@
 	lock( lock __cfaabi_dbg_ctx2 );
 	unpark(
-		pop_head( this.blocked_threads )
+		pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
 	);
 	unlock( lock );
@@ -150,5 +150,5 @@
 	while(this.blocked_threads) {
 		unpark(
-			pop_head( this.blocked_threads )
+			pop_head( this.blocked_threads ) __cfaabi_dbg_ctx2
 		);
 	}
@@ -160,5 +160,5 @@
 	append( this.blocked_threads, kernelTLS.this_thread );
 	unlock( this.lock );
-	park();
+	park( __cfaabi_dbg_ctx );
 }
 
@@ -169,5 +169,5 @@
 	unlock(l);
 	unlock(this.lock);
-	park();
+	park( __cfaabi_dbg_ctx );
 	lock(l);
 }
Index: libcfa/src/concurrency/thread.hfa
===================================================================
--- libcfa/src/concurrency/thread.hfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/concurrency/thread.hfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -92,13 +92,13 @@
 //----------
 // Park thread: block until corresponding call to unpark, won't block if unpark is already called
-void park( void );
+void park( __cfaabi_dbg_ctx_param );
 
 //----------
 // 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 );
+void unpark( $thread * this __cfaabi_dbg_ctx_param2 );
 
 forall( dtype T | is_thread(T) )
-static inline void unpark( T & this ) { if(!&this) return; unpark( get_thread( this ) );}
+static inline void unpark( T & this __cfaabi_dbg_ctx_param2 ) { if(!&this) return; unpark( get_thread( this ) __cfaabi_dbg_ctx_fwd2 );}
 
 //----------
Index: libcfa/src/startup.cfa
===================================================================
--- libcfa/src/startup.cfa	(revision 210b8b3e7bf9fd99156079c5d040467ae45303ed)
+++ libcfa/src/startup.cfa	(revision c72ea7ada1279504439d99e4ecfee9a46c6da894)
@@ -41,5 +41,5 @@
 struct __spinlock_t;
 extern "C" {
-	void __cfaabi_dbg_record(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
+	void __cfaabi_dbg_record_lock(struct __spinlock_t & this, const char prev_name[]) __attribute__(( weak )) {}
 }