Changeset 9042795

Timestamp:

May 2, 2017, 7:18:52 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

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:

6db9dab

Parents:

ed8a0d2 (diff), b510ac2 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:/u/cforall/software/cfa/cfa-cc

Files:

• Jenkinsfile (modified) (1 diff)
• src/benchmark/CorCtxSwitch.c (modified) (1 diff)
• src/benchmark/bench.c (modified) (5 diffs)
• src/benchmark/csv-data.c (modified) (1 diff)
• src/libcfa/concurrency/monitor.c (modified) (4 diffs)
• src/tests/.expect/concurrent/sched-int-multi.txt (modified) (1 diff)
• src/tests/sched-int-multi.c (modified) (1 diff)

Jenkinsfile

@@ -371 +371 @@
 """
 
-        def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com"
+        def email_to = "pabuhr@uwaterloo.ca, rschlunt@uwaterloo.ca, a3moss@uwaterloo.ca, tdelisle@uwaterloo.ca, brice.dobry@huawei.com, ajbeach@edu.uwaterloo.ca"
 
         //send email notification

src/benchmark/CorCtxSwitch.c

@@ -23 +23 @@
 } // Time
 
-struct GreatSuspender {
-        coroutine_desc __cor;
-};
-
-DECL_COROUTINE(GreatSuspender);
+coroutine GreatSuspender {};
 
 void ?{}( GreatSuspender * this ) {

src/benchmark/bench.c

@@ -86 +86 @@
 //=======================================
 
-struct CoroutineDummy { coroutine_desc __cor; };
-DECL_COROUTINE(CoroutineDummy);
+coroutine CoroutineDummy {};
 void main(CoroutineDummy * this) {}
 
@@ -117 +116 @@
 }
 
-struct CoroutineResume {
+coroutine CoroutineResume {
     int N;
-    coroutine_desc __cor;
 };
-
-DECL_COROUTINE(CoroutineResume);
 
 void ?{}(CoroutineResume* this, int N) {
@@ -150 +146 @@
 //=======================================
 
-struct ThreadDummy { thread_desc __thrd; };
-DECL_THREAD(ThreadDummy);
+thread ThreadDummy {};
 void main(ThreadDummy * this) {}
 
@@ -177 +172 @@
 }
 
-struct ContextSwitch {
+thread ContextSwitch {
     int N;
     long long result;
-    thread_desc __thrd;
 };
-
-DECL_THREAD(ContextSwitch);
 
 void main(ContextSwitch * this) {    
@@ -241 +233 @@
         DynamicTaskCreateDelete( NoOfTimes );
         {
-                scoped(ContextSwitch) dummy = { (int)NoOfTimes };               // context switch
+                ContextSwitch dummy = { (int)NoOfTimes };               // context switch
         }
         sout | "\t" | endl;

src/benchmark/csv-data.c

@@ -25 +25 @@
 } // Time
 
-struct GreatSuspender {
-        coroutine_desc __cor;
-};
-
-DECL_COROUTINE(GreatSuspender);
+coroutine GreatSuspender {};
 
 void ?{}( GreatSuspender * this ) {

src/libcfa/concurrency/monitor.c

@@ -17 +17 @@
 #include "monitor"
 
+#include <stdlib>
+
 #include "kernel_private.h"
 #include "libhdr.h"
@@ -130 +132 @@
         this_thread()->current_monitors      = this->prev_mntrs;
         this_thread()->current_monitor_count = this->prev_count;
+}
+
+void debug_break() __attribute__(( noinline ))
+{
+        
 }
 
@@ -171 +178 @@
 
         //Find the next thread(s) to run
-        unsigned short thread_count = count;
+        unsigned short thread_count = 0;
         thread_desc * threads[ count ];
+        for(int i = 0; i < count; i++) {
+                threads[i] = 0;
+        }
+
+        debug_break();
 
         for( int i = 0; i < count; i++) {
                 thread_desc * new_owner = next_thread( this->monitors[i] );
-                thread_count = insert_unique( threads, i, new_owner );
-        }
+                thread_count = insert_unique( threads, thread_count, new_owner );
+        }
+
+        debug_break();
 
         LIB_DEBUG_PRINT_SAFE("Will unblock: ");
@@ -339 +353 @@
                 LIB_DEBUG_PRINT_SAFE("Branding\n");
                 assertf( thrd->current_monitors != NULL, "No current monitor to brand condition", thrd->current_monitors );
-                this->monitors = thrd->current_monitors;
                 this->monitor_count = thrd->current_monitor_count;
+
+                this->monitors = malloc( this->monitor_count * sizeof( *this->monitors ) );
+                for( int i = 0; i < this->monitor_count; i++ ) {
+                        this->monitors[i] = thrd->current_monitors[i];
+                }
         }
 }
 
 static inline unsigned short insert_unique( thread_desc ** thrds, unsigned short end, thread_desc * val ) {
-        for(int i = 0; i < end; i++) {
+        if( !val ) return end;
+
+        for(int i = 0; i <= end; i++) {
                 if( thrds[i] == val ) return end;
         }

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

@@ -1 @@
-Waiting All
-Entering A
-Entering A & B
-Signal
-Leaving  A & B
-Leaving  A
-Done waiting
+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

src/tests/sched-int-multi.c

@@ -4 +4 @@
 #include <thread>
 
+enum state_t { WAIT, SIGNAL, BARGE };
+
 monitor global_t {};
 
+monitor global_data_t {
+        bool done;
+        int counter;
+        state_t state;
+};
+
+void ?{} ( global_data_t * this ) {
+        this->done = false;
+        this->counter = 0;
+        this->state = BARGE;
+}
+
+void ^?{} ( global_data_t * this ) {}
+
+global_t globalA;
 global_t globalB;
-global_t globalA;
+global_data_t globalC;
 
 condition cond;
 
-thread Signalee {};
-thread Signaler {};
+thread Threads {};
 
-void signalee_action( global_t * mutex a, global_t * mutex b ) {
-        sout | "Waiting All" | endl;
-        wait( &cond );
-        sout | "Done waiting" | endl;
+bool logicC( global_t * mutex a, global_t * mutex b, global_data_t * mutex c ) {
+        c->counter++;
+
+        int action = c->counter % 10;
+
+        if( action == 1 || action == 3 ) {
+                if(c->state != BARGE) {
+                        sout | "ERROR Mutual exclusion is inconsistent for wait" | endl;
+                        abort();
+                }
+
+                c->state = WAIT;
+                wait( &cond );
+
+                if(c->state != SIGNAL) {
+                        sout | "ERROR Barging detected" | endl;
+                        abort();
+                }
+        }
+        else if( action == 6 ) {
+                if(c->state != BARGE) {
+                        sout | "ERROR Mutual exclusion is inconsistent for signal" | endl;
+                        abort();
+                }
+
+                c->state = SIGNAL;
+
+                signal( &cond );
+                signal( &cond );
+        }
+        else {
+                c->state = BARGE;
+        }
+
+        if( (c->counter % 1000) == 0 ) sout | c->counter | endl;
+        if( c->counter == 100_000 ) c->done = true;
+        return !c->done;
 }
 
-void main( Signalee* this ) {
-        signalee_action( &globalA, &globalB );
+bool logicB( global_t * mutex a, global_t * mutex b ) {
+        return logicC(a, b, &globalC);
 }
 
-void signaler_action_inner( global_t * mutex a, global_t * mutex b ) {
-        sout | "Entering A & B" | endl;
-        sout | "Signal" | endl;
-        signal( &cond );
-        sout | "Leaving  A & B" | endl;
+bool logicA( global_t * mutex a ) {
+        return logicB(a, &globalB);
 }
 
-void signaler_action( global_t * mutex a, global_t * b ) {
-        sout | "Entering A" | endl;
-        signaler_action_inner( a, b );
-        sout | "Leaving  A" | endl;
-}
-
-void main( Signaler* this ) {
-        for(int i = 0; i < 10_000; i++) {
-                asm volatile ("" : : : "memory");
-        }
-
-        signaler_action( &globalA, &globalB );
+void main( Threads* this ) {
+        while( logicA(&globalA) ) { yield(); };
 }
 
 int main(int argc, char* argv[]) {
-        processor p;
+        processor p[3];
         {
-                Signalee a;
-                Signaler b;
+                Threads t[20];
         }
 }