Changeset 7b1f6d4

Timestamp:

Dec 21, 2020, 1:55:24 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

3d19ae6, d411769c

Parents:

5d369c7 (diff), 276a94d7 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

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 (moved) (moved from tests/multi_list.cfa)
• tests/collections/queue.cfa (moved) (moved from tests/queue.cfa) (3 diffs)
• tests/collections/sequence.cfa (moved) (moved from tests/sequence.cfa) (1 diff)
• tests/collections/stack.cfa (moved) (moved from tests/stack.cfa) (1 diff)
• tests/unified_locking/locks.cfa (moved) (moved from tests/locks.cfa) (2 diffs)
• 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 

tests/collections/queue.cfa

@@ -33 +33 @@
         }
 
+        sout | head(fred).i | nl;
+        sout | tail(fred).i | nl;
+
         for ( QueueIter(Fred) iter = { fred }; iter >> f; ) {
                 sout | f.i | ' ';
@@ -50 +53 @@
                 add( fred, *new( 2 * i + 1 ) );
         }
+
+        Fred * front = new( -1 );
+        addHead( fred, *front );
+        sout | succ( fred, front )->i | nl;
+        remove( fred, *front );
+        delete( front );
+
+        Fred & end = dropTail( fred );
+        delete( &end );
+
         for ( over( fredIter, fred ); fredIter >> f; ) {
                 sout | f.i | ' ';
@@ -56 +69 @@
 
         for ( over( fredIter, fred ); fredIter >> f; ) {
+                delete( &f );
+        }
+
+        Queue(Fred) fred0;
+        Fred * middle;
+        for ( i; 10 ) {
+                if( i == 5) {
+                        middle = new( i );
+                        add( fred0, *middle );
+                        continue;
+                }
+                add( fred0, *new( i ) );
+        }
+
+        for ( QueueIter(Fred) iter = { fred0 }; iter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        Queue(Fred) fred2;
+
+        split( fred2, fred0, *middle);
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        for ( over( fredIter, fred2 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        transfer( fred0, fred2);
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
                 delete( &f );
         }

tests/collections/sequence.cfa

@@ -69 +69 @@
 
         for ( over( fredIter, fred ); fredIter >> f; ) {
+                delete( &f );
+        }
+
+        Sequence(Fred) fred0;
+        Fred * middle;
+        for ( i; 10 ) {
+                if( i == 5) {
+                        middle = new( i );
+                        addHead( fred0, *middle );
+                        continue;
+                }
+                addHead( fred0, *new( i ) );
+        }
+
+        for ( SeqIterRev(Fred) iter = { fred0 }; iter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        Fred * front = new( -1 );
+        insertBef( fred0, *front, tail(fred0));
+        insertAft( fred0, *front, *new( -2 ) );
+        remove( fred0, *front );
+        delete( front );
+
+        sout | head(fred0).i | nl;
+        Fred & end = dropTail( fred );
+        delete( &end );
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        Sequence(Fred) fred2;
+
+        split( fred2, fred0, *middle);
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        for ( over( fredIter, fred2 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        transfer( fred0, fred2);
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
+                sout | f.i | ' ';
+        }
+        sout | nl;
+
+        for ( over( fredIter, fred0 ); fredIter >> f; ) {
                 delete( &f );
         }

tests/collections/stack.cfa

@@ -37 +37 @@
         }
         sout | nl;
+
+        sout | head(fred).i | nl;
         
         for ( i; 9 ) {

tests/unified_locking/locks.cfa

@@ -1 +1 @@
 #include <stdio.h>
 #include "locks.hfa"
-
-#include "kernel_private.hfa"
-#include <stdlib.h>
-
-#include <kernel.hfa>
 #include <stdlib.hfa>
 #include <thread.hfa>
@@ -224 +219 @@
 int main() {
         processor p[2];
+        wait( c_s, 1`ns );
         printf("Start Test 1: multi acquisition lock and condition variable single wait/notify\n");
         {