Changeset 102a58b for src/tests

Timestamp:

May 4, 2017, 4:13:36 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

9737ffe

Parents:

4845ae2

Message:

-fixed error in concurrency keywords
-implemented more agressive test for internal scheduling

Location:

src/tests

Files:

• .expect/concurrent/sched-int.txt (modified) (1 diff)
• sched-int.c (modified) (1 diff)

src/tests/.expect/concurrent/sched-int.txt

@@ -1 @@
-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

src/tests/sched-int.c

@@ -4 +4 @@
 #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;
+        }       
 }