Changes in / [7b1f6d4:5d369c7]

Files:

• libcfa/src/concurrency/locks.cfa (modified) (8 diffs)
• libcfa/src/concurrency/locks.hfa (modified) (4 diffs)
• tests/.expect/locks.txt (deleted)
• 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 (deleted)
• tests/collections/multi_list.cfa (deleted)
• tests/collections/queue.cfa (deleted)
• tests/collections/sequence.cfa (deleted)
• tests/collections/stack.cfa (deleted)
• tests/locks.cfa (added)
• tests/multi_list.cfa (added)
• tests/queue.cfa (added)
• tests/sequence.cfa (added)
• tests/stack.cfa (added)
• tests/unified_locking/locks.cfa (deleted)
• tests/unified_locking/timeout_lock.cfa (deleted)

libcfa/src/concurrency/locks.cfa

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

tests/.expect/queue.txt

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