Changes in / [5d369c7:7b1f6d4]

Files:

• libcfa/src/concurrency/locks.cfa (modified) (8 diffs)
• libcfa/src/concurrency/locks.hfa (modified) (4 diffs)
• tests/.expect/locks.txt (added)
• tests/.expect/queue.txt (modified) (1 diff)
• tests/.expect/sequence.txt (modified) (1 diff)
• tests/.expect/stack.txt (modified) (1 diff)
• tests/.expect/timeout_lock.txt (added)
• tests/collections/multi_list.cfa (added)
• tests/collections/queue.cfa (added)
• tests/collections/sequence.cfa (added)
• tests/collections/stack.cfa (added)
• tests/locks.cfa (deleted)
• tests/multi_list.cfa (deleted)
• tests/queue.cfa (deleted)
• tests/sequence.cfa (deleted)
• tests/stack.cfa (deleted)
• tests/unified_locking/locks.cfa (added)
• tests/unified_locking/timeout_lock.cfa (added)

libcfa/src/concurrency/locks.cfa

@@ -17 +17 @@
                 this.t = t;
                 this.lock = 0p;
-                this.listed = false;
         }
 
@@ -25 +24 @@
                 this.info = info;
                 this.lock = 0p;
-                this.listed = false;
         }
 
@@ -36 +34 @@
         info_thread(L) *& Next( info_thread(L) * this ) {
                 return (info_thread(L) *)Next( (Colable *)this );
-        }
-
-        bool listed( info_thread(L) * this ) {
-                return Next( (Colable *)this ) != 0p;
         }
 }
@@ -194 +188 @@
         // This condition_variable member is called from the kernel, and therefore, cannot block, but it can spin.
             lock( cond->lock __cfaabi_dbg_ctx2 );
-            
-            if ( i->listed ) {                  // is thread on queue
+            if ( listed(i) ) {                  // is thread on queue
+                i->signalled = false;
                 cond->last_thread = i;          // REMOVE THIS AFTER DEBUG
                         remove( cond->blocked_threads, *i );             //remove this thread O(1)
@@ -227 +221 @@
         void process_popped( condition_variable(L) & this, info_thread(L) & popped ) with( this ) {
                 if(&popped != 0p) {
-                        popped.listed = false;
+                        popped.signalled = true;
                         count--;
                         if (popped.lock) {
@@ -266 +260 @@
                 addTail( blocked_threads, *i );
                 count++;
-                i->listed = true;
                 size_t recursion_count = 0;
                 if (i->lock) {
@@ -308 +301 @@
         }
         
-        void wait( condition_variable(L) & this, Duration duration ) with(this) {
+        bool wait( condition_variable(L) & this, Duration duration ) with(this) {
                 info_thread( L ) i = { active_thread() };
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-
-        void wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
+                return i.signalled;
+        }
+
+        bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { 
                 info_thread( L ) i = { active_thread(), info };
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-
-        void wait( condition_variable(L) & this, Time time ) with(this) {
+                return i.signalled;
+        }
+
+        bool wait( condition_variable(L) & this, Time time ) with(this) {
                 info_thread( L ) i = { active_thread() };
                 queue_info_thread_timeout(this, i, time);
-        }
-
-        void wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
+                return i.signalled;
+        }
+
+        bool wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) {
                 info_thread( L ) i = { active_thread(), info };
                 queue_info_thread_timeout(this, i, time);
+                return i.signalled;
         }
 
@@ -340 +337 @@
         }
         
-        void wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
+        bool wait( condition_variable(L) & this, L & l, Duration duration ) with(this) {
                 info_thread(L) i = { active_thread() };
                 i.lock = &l;
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
+                return i.signalled;
+        }
+        
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) {
                 info_thread(L) i = { active_thread(), info };
                 i.lock = &l;
                 queue_info_thread_timeout(this, i, __kernel_get_time() + duration );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, Time time ) with(this) {
+                return i.signalled;
+        }
+        
+        bool wait( condition_variable(L) & this, L & l, Time time ) with(this) {
                 info_thread(L) i = { active_thread() };
                 i.lock = &l;
                 queue_info_thread_timeout(this, i, time );
-        }
-        
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
+                return i.signalled;
+        }
+        
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) {
                 info_thread(L) i = { active_thread(), info };
                 i.lock = &l;
                 queue_info_thread_timeout(this, i, time );
-        }
-}
+                return i.signalled;
+        }
+}

libcfa/src/concurrency/locks.hfa

@@ -36 +36 @@
                 uintptr_t info;
                 L * lock;
-                bool listed;                                    // true if info_thread is on queue, false otherwise;
+                bool signalled;                                 // true when signalled and false when timeout wakes thread
         };
 
@@ -46 +46 @@
         info_thread(L) *& Back( info_thread(L) * this );
         info_thread(L) *& Next( info_thread(L) * this );
-        bool listed( info_thread(L) * this );
 }
 
@@ -52 +51 @@
 //// Blocking Locks
 ///////////////////////////////////////////////////////////////////
-
-// struct lock_thread {
-//      struct $thread * t;
-//      lock_thread * next;
-// };
-
-// void ?{}( lock_thread & this, struct $thread * thd );
-// void ^?{}( lock_thread & this );
-
-// lock_thread *& get_next( lock_thread & );
 
 struct blocking_lock {
@@ -183 +172 @@
         int counter( condition_variable(L) & this );
 
-        // TODO: look into changing timout routines to return bool showing if signalled or woken by kernel
         void wait( condition_variable(L) & this );
         void wait( condition_variable(L) & this, uintptr_t info );
-        void wait( condition_variable(L) & this, Duration duration );
-        void wait( condition_variable(L) & this, uintptr_t info, Duration duration );
-        void wait( condition_variable(L) & this, Time time );
-        void wait( condition_variable(L) & this, uintptr_t info, Time time );
+        bool wait( condition_variable(L) & this, Duration duration );
+        bool wait( condition_variable(L) & this, uintptr_t info, Duration duration );
+        bool wait( condition_variable(L) & this, Time time );
+        bool wait( condition_variable(L) & this, uintptr_t info, Time time );
 
         void wait( condition_variable(L) & this, L & l );
         void wait( condition_variable(L) & this, L & l, uintptr_t info );
-        void wait( condition_variable(L) & this, L & l, Duration duration );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
-        void wait( condition_variable(L) & this, L & l, Time time );
-        void wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
+        bool wait( condition_variable(L) & this, L & l, Duration duration );
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration );
+        bool wait( condition_variable(L) & this, L & l, Time time );
+        bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time );
 }

tests/.expect/queue.txt

@@ -1 +1 @@
 empty
+0
+18
 0 2 4 6 8 10 12 14 16 18 
 18 
-18 1 3 5 7 9 11 13 15 17 19 
+18
+18 1 3 5 7 9 11 13 15 17 
+0 1 2 3 4 5 6 7 8 9 
+6 7 8 9 
+0 1 2 3 4 5 
+6 7 8 9 0 1 2 3 4 5 
 empty
 0 0 2 2 4 4 6 6 8 8 10 10 12 12 14 14 16 16 18 18 

tests/.expect/sequence.txt

@@ -4 +4 @@
 18 1 3 5 7 9 11 13 15 17 19 
 18 1 
+0 1 2 3 4 5 6 7 8 9 
+9
+9 8 7 6 5 4 3 1 -2 0 
+4 3 1 -2 0 
+9 8 7 6 5 
+4 3 1 -2 0 9 8 7 6 5 
 empty
 0 0 2 2 4 4 6 6 8 8 10 10 12 12 14 14 16 16 18 18 

tests/.expect/stack.txt

@@ -1 +1 @@
 empty
 18 16 14 12 10 8 6 4 2 0 
+18
 0 
 19 17 15 13 11 9 7 5 3 1 0