Changeset 4e83bb7

Timestamp:

Jun 23, 2022, 1:41:29 PM (2 years ago)

Author:

caparsons <caparson@…>

Branches:

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

Children:

d28524a

Parents:

1dbbef6

Message:

fixed timeout cond var bug and updated pthread_locks test with timeout lock test

Files:

• libcfa/src/concurrency/locks.cfa (modified) (6 diffs)
• tests/unified_locking/.expect/pthread_locks.txt (modified) (1 diff)
• tests/unified_locking/pthread_locks.cfa (modified) (3 diffs)

libcfa/src/concurrency/locks.cfa

@@ -237 +237 @@
                 // This pthread_cond_var member is called from the kernel, and therefore, cannot block, but it can spin.
                 lock( cond->lock __cfaabi_dbg_ctx2 );
-
                 // this check is necessary to avoid a race condition since this timeout handler
                 //      may still be called after a thread has been removed from the queue but
@@ -347 +346 @@
                 size_t recursion_count = queue_and_get_recursion(this, &info);
                 alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
+                unlock( lock );
+
+                // registers alarm outside cond lock to avoid deadlock
                 register_self( &node_wrap.alarm_node );
-                unlock( lock );
 
                 // blocks here
@@ -437 +438 @@
                 if ( ret ) {
                         info_thread(L) & popped = try_pop_front( blocked_threads );
+                        popped.signalled = true;
                         on_notify(*popped.lock, popped.t);
                 }
@@ -448 +450 @@
                 while( ! blocked_threads`isEmpty ) {
                         info_thread(L) & popped = try_pop_front( blocked_threads );
+                        popped.signalled = true;
                         on_notify(*popped.lock, popped.t);
                 }
@@ -469 +472 @@
                 size_t recursion_count = queue_and_get_recursion(this, &info);
                 pthread_alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
+                unlock( lock );
+
+                // registers alarm outside cond lock to avoid deadlock
                 register_self( &node_wrap.alarm_node );
-                unlock( lock );
 
                 // blocks here
@@ -500 +505 @@
                 return i.signalled;
 
+        Duration getDuration(timespec t) {
+                timespec currTime;
+                clock_gettime(CLOCK_REALTIME, &currTime);
+                Duration waitUntil = { t };
+                Duration currDur = { currTime };
+                if ( currDur >= waitUntil ) return currDur - waitUntil;
+                Duration zero = { 0 };
+                return zero;
+        }
+
         bool wait( pthread_cond_var(L) & this, L & l, timespec t ) {
-                Duration d = { t };
-                WAIT_TIME( 0, &l , d )
+                PTHREAD_WAIT_TIME( 0, &l , getDuration( t ) )
         }
         
         bool wait( pthread_cond_var(L) & this, L & l, uintptr_t info, timespec t  ) {
-                Duration d = { t };
-                WAIT_TIME( info, &l , d )
+                PTHREAD_WAIT_TIME( info, &l , getDuration( t ) )
         }
 }

tests/unified_locking/.expect/pthread_locks.txt

@@ -5 +5 @@
 Start Test 3: lock and condition variable multiple acquire and wait/notify
 Done Test 3
+Start Test 4: lock and condition variable single timed wait/notify
+Done Test 4

tests/unified_locking/pthread_locks.cfa

@@ -3 +3 @@
 #include <stdlib.hfa>
 #include <thread.hfa>
+#include <time.h>
+#include <stdlib.hfa>
 
-const unsigned int num_times = 50000;
+const unsigned int num_times = 50;
 
 simple_owner_lock l;
 pthread_cond_var( simple_owner_lock ) c;
+
+owner_lock l2;
+condition_variable( owner_lock ) c2;
 
 volatile int counter = 0;
@@ -59 +64 @@
 }
 
+thread Wait_Time_Signal_1 {};
+
+void main( Wait_Time_Signal_1 & this ) {
+        for (unsigned int i = 0; i < num_times; i++) {
+                lock(l);
+                if(empty(c) || random(10) >= 9 ) {
+                        timespec t;
+                        clock_gettime(CLOCK_REALTIME, &t);
+                        timespec waitTime{0,1};
+                        bool woken = wait(c,l, t + waitTime);
+                }else{
+                        notify_one(c);
+                }
+                unlock(l);
+        }
+}
+
 int main() {
-        processor p[3];
+        processor p[1];
         printf("Start Test 1: lock and condition variable single wait/notify\n");
         {
@@ -78 +100 @@
         }
         printf("Done Test 3\n");
+
+        printf("Start Test 4: lock and condition variable single timed wait/notify\n");
+        {
+                Wait_Time_Signal_1 t1[2];
+        }
+        printf("Done Test 4\n");
 }