Changeset 51239d1b for tests/concurrent/mutexstmt

Timestamp:

Mar 21, 2022, 11:50:25 AM (2 years ago)

Author:

caparsons <caparson@…>

Branches:

ADT, ast-experimental, enum, master, pthread-emulation, qualifiedEnum

Children:

080d2d7

Parents:

22226e4

Message:

added new mutexstmt tests

Location:

tests/concurrent/mutexstmt

Files:

• .expect/locks.txt (modified) (1 diff)
• locks.cfa (modified) (4 diffs)

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

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

tests/concurrent/mutexstmt/locks.cfa

@@ -4 +4 @@
 
 const unsigned int num_times = 10000;
+
+Duration default_preemption() { return 0; }
 
 single_acquisition_lock m1, m2, m3, m4, m5;
@@ -23 +25 @@
 }
 
+void refTest( single_acquisition_lock & m ) {
+        mutex ( m ) {
+                assert(!insideFlag);
+                insideFlag = true;
+                assert(insideFlag);
+                insideFlag = false;
+        }
+}
+
 thread T_Multi {};
 
 void main( T_Multi & this ) {
         for (unsigned int i = 0; i < num_times; i++) {
+                refTest( m1 );
                 mutex ( m1 ) {
                         assert(!insideFlag);
@@ -60 +72 @@
 }
 
+single_acquisition_lock l1;
+linear_backoff_then_block_lock l2;
+owner_lock l3;
+
+thread T_Multi_Poly {};
+
+void main( T_Multi_Poly & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                refTest( l1 );
+                mutex ( l1 ) {
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                mutex ( l1, l2, l3 ) {
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                mutex ( l3, l1 ) {
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+                mutex ( l1, l2 ) {
+                        assert(!insideFlag);
+                        insideFlag = true;
+                        assert(insideFlag);
+                        insideFlag = false;
+                }
+        }
+}
+
 int num_tasks = 10;
 int main() {
-        processor p[10];
+        processor p[num_tasks - 1];
 
         printf("Start Test: single lock mutual exclusion\n");
         {
-                T_Mutex t[10];
+                T_Mutex t[num_tasks];
         }
         assert(count == num_tasks * num_times);
@@ -72 +120 @@
         printf("Start Test: multi lock deadlock/mutual exclusion\n");
         {
-                T_Multi t[10];
+                T_Multi t[num_tasks];
         }
         printf("End Test: multi lock deadlock/mutual exclusion\n");
+        printf("Start Test: multi polymorphic lock deadlock/mutual exclusion\n");
+        {
+                T_Multi_Poly t[num_tasks];
+        }
+        printf("End Test: multi polymorphic lock deadlock/mutual exclusion\n");
 }