Changeset b56ad5e for tests/concurrent

Timestamp:

Feb 4, 2022, 10:10:34 PM (4 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, ast-experimental, enum, forall-pointer-decay, master, pthread-emulation, qualifiedEnum

Children:

f8143a6

Parents:

5f3ba11 (diff), 67e86ae6 (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:software/cfa/cfa-cc

Location:

tests/concurrent

Files:

• .expect/ctor-check.txt (modified) (1 diff)
• .expect/preempt2.txt (added)
• mutexstmt/.expect/locks.txt (modified) (1 diff)
• mutexstmt/locks.cfa (modified) (3 diffs)
• preempt.cfa (modified) (4 diffs)
• preempt2.cfa (added)

tests/concurrent/.expect/ctor-check.txt

@@ -2 +2 @@
 ?{}: function
 ... with parameters
-  lvalue reference to instance of struct Empty with body
+  this: lvalue reference to instance of struct Empty with body
 ... returning nothing
  with body

tests/concurrent/mutexstmt/.expect/locks.txt

@@ -3 +3 @@
 Start Test: multi lock deadlock/mutual exclusion
 End Test: multi lock deadlock/mutual exclusion
+Start Test: single scoped lock mutual exclusion
+End Test: single scoped lock mutual exclusion
+Start Test: multi scoped lock deadlock/mutual exclusion
+End Test: multi scoped lock deadlock/mutual exclusion

tests/concurrent/mutexstmt/locks.cfa

@@ -59 +59 @@
 }
 
+thread T_Mutex_Scoped {};
 
+void main( T_Mutex_Scoped & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        count++;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+        }
+}
+
+thread T_Multi_Scoped {};
+
+void main( T_Multi_Scoped & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                {
+                        scoped_lock(single_acquisition_lock) s{m1};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s2{m2};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        scoped_lock(single_acquisition_lock) s5{m5};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s2{m2};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                {
+                        scoped_lock(single_acquisition_lock) s1{m1};
+                        scoped_lock(single_acquisition_lock) s3{m3};
+                        scoped_lock(single_acquisition_lock) s4{m4};
+                        scoped_lock(single_acquisition_lock) s5{m5};
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+        }
+}
+
+int num_tasks = 10;
 int main() {
         processor p[10];
@@ -67 +137 @@
                 T_Mutex t[10];
         }
+        assert(count == num_tasks * num_times);
         printf("End Test: single lock mutual exclusion\n");
         printf("Start Test: multi lock deadlock/mutual exclusion\n");
@@ -73 +144 @@
         }
         printf("End Test: multi lock deadlock/mutual exclusion\n");
+        
+        count = 0;
+        printf("Start Test: single scoped lock mutual exclusion\n");
+        {
+                T_Mutex_Scoped t[10];
+        }
+        assert(count == num_tasks * num_times);
+        printf("End Test: single scoped lock mutual exclusion\n");
+        printf("Start Test: multi scoped lock deadlock/mutual exclusion\n");
+        {
+                T_Multi_Scoped t[10];
+        }
+        printf("End Test: multi scoped lock deadlock/mutual exclusion\n");      
 }

tests/concurrent/preempt.cfa

@@ +1 @@
+#include <clock.hfa>
 #include <fstream.hfa>
 #include <kernel.hfa>
@@ -22 +23 @@
 extern void __cfaabi_check_preemption();
 
-static volatile int counter = 0;
+static struct {
+        volatile int counter;
+        volatile Time prev;
+        Duration durations[6];
+} globals;
 
 thread worker_t {
         int value;
-        unsigned spin;
+        unsigned long long spin;
 };
 
@@ -35 +40 @@
 
 void main(worker_t & this) {
-        while(TEST(counter < N)) {
-                if(this.spin > 100_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
+        while(TEST(globals.counter < N)) {
+                if(this.spin > 50_000_000_000) abort | "Worker" | this.value | "has been spinning too long! (" | this.spin | ")";
                 __cfaabi_check_preemption();
-                if( (counter % 7) == this.value ) {
+                if( (globals.counter % 7) == this.value ) {
                         __cfaabi_check_preemption();
-                        int next = __atomic_add_fetch( &counter, 1, __ATOMIC_SEQ_CST );
+                        #if !defined(TEST_LONG)
+                                Time now = timeHiRes();
+                                Duration diff = now - globals.prev;
+                                globals.prev = now;
+                        #endif
+                        int next = __atomic_add_fetch( &globals.counter, 1, __ATOMIC_SEQ_CST );
                         __cfaabi_check_preemption();
-                        if( (next % 100) == 0 ) printf("%d\n", (int)next);
+                        if( (next % 100) == 0 ) {
+                                #if !defined(TEST_LONG)
+                                        unsigned idx = next / 100;
+                                        if (idx >= 6) abort | "Idx from next is invalid: " | idx | "vs" | next;
+                                        globals.durations[idx] = diff;
+                                        if(diff > 12`s) serr | "Duration suspiciously large:" | diff;
+                                #endif
+                                printf("%d\n", (int)next);
+
+                        }
                         __cfaabi_check_preemption();
                         this.spin = 0;
@@ -54 +73 @@
 int main(int argc, char* argv[]) {
         processor p;
+        globals.counter = 0;
+        globals.durations[0] = 0;
+        globals.durations[1] = 0;
+        globals.durations[2] = 0;
+        globals.durations[3] = 0;
+        globals.durations[4] = 0;
+        globals.durations[5] = 0;
         {
+                globals.prev = timeHiRes();
                 worker_t w0 = 0;
                 worker_t w1 = 1;