Changeset eb5962a for libcfa/src/concurrency/kernel

Timestamp:

Jun 21, 2022, 1:39:24 PM (4 years ago)

Author:

JiadaL <j82liang@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum, stuck-waitfor-destruct

Children:

b62d1d6

Parents:

1df492a (diff), 1dbbef6 (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

File:

• libcfa/src/concurrency/kernel/fwd.hfa (modified) (5 diffs)

libcfa/src/concurrency/kernel/fwd.hfa

@@ -200 +200 @@
                                         struct thread$ * expected = this.ptr;
                                         if(expected == 1p) return false;
-                                        /* paranoid */ verify( expected == 0p );
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, active_thread(), false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                                 park();
@@ -213 +212 @@
                         thread$ * post(oneshot & this, bool do_unpark = true) {
                                 struct thread$ * got = __atomic_exchange_n( &this.ptr, 1p, __ATOMIC_SEQ_CST);
-                                if( got == 0p ) return 0p;
+                                if( got == 0p || got == 1p ) return 0p;
                                 if(do_unpark) unpark( got );
                                 return got;
@@ -263 +262 @@
 
                                         // The future is not fulfilled, try to setup the wait context
-                                        /* paranoid */ verify( expected == 0p );
                                         if(__atomic_compare_exchange_n(&this.ptr, &expected, &wait_ctx, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
                                                 return true;
@@ -275 +273 @@
                         // should retract the wait ctx
                         // intented to be use by wait, wait_any, waitfor, etc. rather than used directly
-                        void retract( future_t & this, oneshot & wait_ctx ) {
-                                // Remove the wait context
-                                struct oneshot * got = __atomic_exchange_n( &this.ptr, 0p, __ATOMIC_SEQ_CST);
-
-                                // got == 0p: future was never actually setup, just return
-                                if( got == 0p ) return;
-
-                                // got == wait_ctx: since fulfil does an atomic_swap,
-                                // if we got back the original then no one else saw context
-                                // It is safe to delete (which could happen after the return)
-                                if( got == &wait_ctx ) return;
-
-                                // got == 1p: the future is ready and the context was fully consumed
-                                // the server won't use the pointer again
-                                // It is safe to delete (which could happen after the return)
-                                if( got == 1p ) return;
-
-                                // got == 2p: the future is ready but the context hasn't fully been consumed
-                                // spin until it is safe to move on
-                                if( got == 2p ) {
-                                        while( this.ptr != 1p ) Pause();
-                                        return;
-                                }
-
-                                // got == any thing else, something wen't wrong here, abort
-                                abort("Future in unexpected state");
+                        bool retract( future_t & this, oneshot & wait_ctx ) {
+                                for() {
+                                        struct oneshot * expected = this.ptr;
+
+                                        // expected == 0p: future was never actually setup, just return
+                                        if( expected == 0p ) return false;
+
+                                        // expected == 1p: the future is ready and the context was fully consumed
+                                        // the server won't use the pointer again
+                                        // It is safe to delete (which could happen after the return)
+                                        if( expected == 1p ) return true;
+
+                                        // expected == 2p: the future is ready but the context hasn't fully been consumed
+                                        // spin until it is safe to move on
+                                        if( expected == 2p ) {
+                                                while( this.ptr != 1p ) Pause();
+                                                /* paranoid */ verify( this.ptr == 1p );
+                                                return true;
+                                        }
+
+                                        // expected != wait_ctx: the future was setup with a different context ?!?!
+                                        // something went wrong here, abort
+                                        if( expected != &wait_ctx ) abort("Future in unexpected state");
+
+                                        // we still have the original context, then no one else saw it
+                                        // attempt to remove the context so it doesn't get consumed.
+                                        if(__atomic_compare_exchange_n( &this.ptr, &expected, 0p, false, __ATOMIC_SEQ_CST, __ATOMIC_SEQ_CST)) {
+                                                return false;
+                                        }
+                                }
                         }
 
@@ -379 +381 @@
                                 return ret;
                         }
+
+                        // Wait for any future to be fulfilled
+                        forall(T& | sized(T) | { bool setup( T&, oneshot & ); bool retract( T&, oneshot & ); })
+                        T & wait_any( T * futures, size_t num_futures ) {
+                                oneshot temp;
+
+                                // setup all futures
+                                // if any are already satisfied return
+                                for ( i; num_futures ) {
+                                        if( !setup(futures[i], temp) ) return futures[i];
+                                }
+
+                                // Wait context is setup, just wait on it
+                                wait( temp );
+
+                                size_t ret;
+                                // attempt to retract all futures
+                                for ( i; num_futures ) {
+                                        if ( retract( futures[i], temp ) ) ret = i;
+                                }
+
+                                return futures[ret];
+                        }
                 }