Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 4845ae2748facdf39ec2df3aaba15448ed6cd16f)
+++ src/Concurrency/Keywords.cc	(revision 102a58b77bb744015a557bbe3dbad51e39e3965f)
@@ -246,4 +246,5 @@
 	//=============================================================================================
 	void ConcurrentSueKeyword::visit(StructDecl * decl) {
+		Visitor::visit(decl);
 		if( decl->get_name() == type_name ) {
 			assert( !type_decl );
@@ -385,4 +386,6 @@
 	//=============================================================================================
 	void MutexKeyword::visit(FunctionDecl* decl) {
+		Visitor::visit(decl);		
+
 		std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl );
 		if( mutexArgs.empty() ) return;
@@ -402,4 +405,6 @@
 
 	void MutexKeyword::visit(StructDecl* decl) {
+		Visitor::visit(decl);
+
 		if( decl->get_name() == "monitor_desc" ) {
 			assert( !monitor_decl );
@@ -504,4 +509,6 @@
 	//=============================================================================================
 	void ThreadStarter::visit(FunctionDecl * decl) {
+		Visitor::visit(decl);
+		
 		if( ! InitTweak::isConstructor(decl->get_name()) ) return;
 
Index: src/tests/.expect/concurrent/sched-int.txt
===================================================================
--- src/tests/.expect/concurrent/sched-int.txt	(revision 4845ae2748facdf39ec2df3aaba15448ed6cd16f)
+++ src/tests/.expect/concurrent/sched-int.txt	(revision 102a58b77bb744015a557bbe3dbad51e39e3965f)
@@ -1,3 +1,101 @@
-Step 1
-Step 2
-Step 3
+1000
+2000
+3000
+4000
+5000
+6000
+7000
+8000
+9000
+10000
+11000
+12000
+13000
+14000
+15000
+16000
+17000
+18000
+19000
+20000
+21000
+22000
+23000
+24000
+25000
+26000
+27000
+28000
+29000
+30000
+31000
+32000
+33000
+34000
+35000
+36000
+37000
+38000
+39000
+40000
+41000
+42000
+43000
+44000
+45000
+46000
+47000
+48000
+49000
+50000
+51000
+52000
+53000
+54000
+55000
+56000
+57000
+58000
+59000
+60000
+61000
+62000
+63000
+64000
+65000
+66000
+67000
+68000
+69000
+70000
+71000
+72000
+73000
+74000
+75000
+76000
+77000
+78000
+79000
+80000
+81000
+82000
+83000
+84000
+85000
+86000
+87000
+88000
+89000
+90000
+91000
+92000
+93000
+94000
+95000
+96000
+97000
+98000
+99000
+100000
+All waiter done
Index: src/tests/sched-int.c
===================================================================
--- src/tests/sched-int.c	(revision 4845ae2748facdf39ec2df3aaba15448ed6cd16f)
+++ src/tests/sched-int.c	(revision 102a58b77bb744015a557bbe3dbad51e39e3965f)
@@ -4,57 +4,112 @@
 #include <thread>
 
-monitor global_t {
-	int value;
-};
+#define N 100_000
 
-global_t global;
+enum state_t { WAIT, SIGNAL, BARGE };
+
+monitor global_t {};
+global_t mut;
+
+monitor global_data_t;
+void ?{}( global_data_t * this );
+void ^?{} ( global_data_t * this );
+
+monitor global_data_t {
+	int counter;
+	state_t state;
+} data;
 
 condition cond;
 
-thread Signalee {};
-thread Signaler {};
+volatile bool all_done;
 
-void step1( global_t * mutex this ) {
-	sout | "Step 1" | endl;
-	this->value = 1;
-	wait( &cond );
+void ?{}( global_data_t * this ) {
+	this->counter == 0;
+	this->state = BARGE;
 }
 
-void step2( global_t * mutex this ) {
-	if( this->value != 1) abort();
+void ^?{} ( global_data_t * this ) {}
 
-	sout | "Step 2" | endl;
-	this->value = 2;
-	signal( &cond );
+//------------------------------------------------------------------------------
+// Barging logic
+void barge( global_data_t * mutex d ) {
+	d->state = BARGE;
 }
 
-void step3( global_t * mutex this ) {
-	if( this->value != 2) abort();
+thread Barger {};
 
-	sout | "Step 3" | endl;
-	this->value = 3;
-	signal( &cond );
+void main( Barger * this ) {
+	while( !all_done ) { 
+		barge( &data );
+		yield(); 
+	}
 }
 
-void main( Signalee* this ) {
-	step1( &global );
-	step3( &global );
+//------------------------------------------------------------------------------
+// Waiting logic
+bool wait( global_t * mutex m, global_data_t * mutex d ) {
+	wait( &cond );
+	if( d->state != SIGNAL ) {
+		sout | "ERROR barging!" | endl; 
+	}
+
+	d->counter++;
+
+	if( (d->counter % 1000) == 0 ) sout | d->counter | endl;
+
+	return d->counter < N;
 }
 
-void main( Signaler* this ) {
-	for(int i = 0; i < 10_000; i++) {
-		asm volatile ("" : : : "memory");
+thread Waiter {};
+
+void main( Waiter * this ) {
+	while( wait( &mut, &data ) ) { yield(); }
+}
+
+
+//------------------------------------------------------------------------------
+// Signalling logic
+void signal( condition * cond, global_t * mutex a, global_data_t * mutex b ) {
+	b->state = SIGNAL;
+	signal( cond );
+}
+
+void logic( global_t * mutex a ) {
+	signal( &cond, a, &data );
+
+	int pauses = (unsigned)rand48() % 10;
+	for(int i = 0; i < pauses; i++) {
+		yield();
 	}
 
-	step2( &global );
+	//This is technically a mutual exclusion violation but the mutex monitor protects us
+	bool running = data.counter < N && data.counter > 0;
+	if( data.state != SIGNAL && running ) {
+		sout | "ERROR Eager signal" | data.state | endl; 
+	}
 }
 
+thread Signaller {};
+
+void main( Signaller * this ) {
+	while( !all_done ) { 
+		logic( &mut );
+		yield(); 
+	}
+}
+
+//------------------------------------------------------------------------------
+// Main loop
 int main(int argc, char* argv[]) {
-	assert( global.__mon.entry_queue.tail != NULL );
+	all_done = false;
 	processor p;
 	{
-		Signalee a;
-		Signaler b;
-	}
-	if( global.value != 3) abort();
+		Signaller s;
+		Barger b[17];
+		{
+			Waiter w[4];
+		}
+		sout | "All waiter done" | endl;
+		all_done = true;
+	}	
 }