Changes in / [4fcbf26:97fed44]

Files:

• libcfa/src/concurrency/mutex_stmt.hfa (modified) (1 diff)
• tests/concurrent/mutexstmt/.expect/locks.txt (modified) (1 diff)
• tests/concurrent/mutexstmt/locks.cfa (modified) (3 diffs)

libcfa/src/concurrency/mutex_stmt.hfa

@@ -38 +38 @@
     }
 
+    struct scoped_lock {
+        L * internal_lock;
+    };
+
+    static inline void ?{}( scoped_lock(L) & this, L & internal_lock ) {
+        this.internal_lock = &internal_lock;
+        lock(internal_lock);
+    }
+    
+    static inline void ^?{}( scoped_lock(L) & this ) with(this) {
+        unlock(*internal_lock);
+    }
+
     static inline L * __get_ptr( L & this ) {
         return &this;

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");      
 }