Changeset 00aa122

Timestamp:

Nov 24, 2025, 4:13:37 PM (6 hours ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

master

Parents:

fbaea970

Message:

harmonize single_future with other future types, remove multi_future, marks its test as deprecated, and turn off its test

Files:

• libcfa/src/concurrency/future.hfa (modified) (4 diffs)
• tests/concurrency/futures/.expect/multi.txt.off (moved) (moved from tests/concurrency/futures/.expect/multi.txt )
• tests/concurrency/futures/multi.cfa (modified) (1 diff)
• tests/concurrency/futures/typed.cfa (modified) (5 diffs)

libcfa/src/concurrency/future.hfa

@@ -10 +10 @@
 // Created On       : Wed Jan 06 17:33:18 2021
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Nov 23 22:48:08 2025
-// Update Count     : 208
+// Last Modified On : Mon Nov 24 16:08:52 2025
+// Update Count     : 222
 //
 
@@ -100 +100 @@
                         except = 0p;
                         state = FUTURE_EMPTY$;
-                        lock{};
                 }
 
@@ -320 +319 @@
 
 //--------------------------------------------------------------------------------------------------------
-// These futures below do not support waituntil statements so they may not have as many features as 'future'
-//  however the 'single_future' is cheap and cheerful and is most likely more performant than 'future'
-//  since it uses raw atomics and no locks
-//
-// As far as 'multi_future' goes I can't see many use cases as it will be less performant than 'future'
-//  since it is monitor based and also is not compatible with waituntil statement.
+// This future does not support waituntil statements so it does not have as many features as 'future'.
+// However, it is cheap and cheerful and is more performant than 'future' since it uses raw atomics
+// and no locks
 //--------------------------------------------------------------------------------------------------------
 
 forall( T ) {
+        // PUBLIC
+
         struct single_future {
                 inline future_t;
@@ -335 +333 @@
 
         static inline {
-                // Reset future back to original state
-                void reset(single_future(T) & this) { reset( (future_t&)this ); }
-
-                // check if the future is available
-                bool available( single_future(T) & this ) { return available( (future_t&)this ); }
-
-                // Mark the future as abandoned, meaning it will be deleted by the server
-                // This doesn't work beause of the potential need for a destructor
-                // void abandon( single_future(T) & this );
-
-                // Fulfil the future, returns whether or not someone was unblocked
-                thread$ * fulfil( single_future(T) & this, T result ) {
-                        this.result = result;
-                        return fulfil( (future_t&)this );
-                }
-
-                // Wait for the future to be fulfilled
-                // Also return whether the thread had to block or not
-                [T, bool] wait( single_future(T) & this ) {
-                        bool r = wait( (future_t&)this );
-                        return [this.result, r];
-                }
-
-                // Wait for the future to be fulfilled
-                T wait( single_future(T) & this ) {
-                        [T, bool] tt;
-                        tt = wait( this );
-                        return tt.0;
-                }
-        }
-}
-
-forall( T ) {
-        monitor multi_future {
-                inline future_t;
-                condition blocked;
-                bool has_first;
-                T result;
-        };
-
-        static inline {
-                void ?{}(multi_future(T) & this) {
-                        this.has_first = false;
-                }
-
-                bool $first( multi_future(T) & mutex this ) {
-                        if ( this.has_first ) {
-                                wait( this.blocked );
-                                return false;
-                        }
-
-                        this.has_first = true;
-                        return true;
-                }
-
-                void $first_done( multi_future(T) & mutex this ) {
-                        this.has_first = false;
-                        signal_all( this.blocked );
-                }
-
-                // Reset future back to original state
-                void reset(multi_future(T) & mutex this) {
-                        if ( this.has_first != false ) abort("Attempting to reset a multi_future with at least one blocked threads");
-                        if ( ! empty( this.blocked ) ) abort("Attempting to reset a multi_future with multiple blocked threads");
-                        reset( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-                }
-
-                // Fulfil the future, returns whether or not someone was unblocked
-                bool fulfil( multi_future(T) & this, T result ) {
-                        this.result = result;
-                        return fulfil( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) ) != 0p;
-                }
-
-                // Wait for the future to be fulfilled
-                // Also return whether the thread had to block or not
-                [T, bool] wait( multi_future(T) & this ) {
-                        bool sw = $first( this );
-                        bool w = !sw;
-                        if ( sw ) {
-                                w = wait( (future_t&)*(future_t*)((uintptr_t)&this + sizeof(monitor$)) );
-                                $first_done( this );
-                        }
-
-                        return [this.result, w];
-                }
-
-                // Wait for the future to be fulfilled
-                T wait( multi_future(T) & this ) {
-                        return wait( this ).0;
-                }
-        }
-}
+                // PUBLIC
+
+                bool available( single_future(T) & fut ) { return available( (future_t &)fut ); } // future result available ?
+
+                // Return a value/exception from the future.
+                [T, bool] get( single_future(T) & fut ) { return [fut.result, wait( fut )]; }
+                T get( single_future(T) & fut ) { wait( fut ); return fut.result; }
+                T ?()( single_future(T) & fut ) { return get( fut ); }  // alternate interface
+
+                // Load a value into the future, returns whether or not waiting threads.
+                bool fulfil( single_future(T) & fut, T result ) {
+                        fut.result = result;
+                        return fulfil( (future_t &)fut ) != 0p;
+                }
+                bool ?()( single_future(T) & fut, T val ) { return fulfil( fut, val ); } // alternate interface
+
+                void reset( single_future(T) & fut ) { reset( (future_t &)fut ); } // mark future as empty (for reuse)
+        } // static inline
+} // forall( T )

tests/concurrency/futures/multi.cfa

@@ +1 @@
+// DEPRECATED future type multi_future. Eventually remove this test.
+
 #include <thread.hfa>
 #include <future.hfa>

tests/concurrency/futures/typed.cfa

@@ -8 +8 @@
 };
 
-void ?{}( Server & this ) {
-        this.cnt = 0;
-        for(i; NFUTURES) {
-                this.requests[i] = 0p;
+void ?{}( Server & server ) with( server ) {
+        cnt = 0;
+        for ( i; NFUTURES ) {
+                requests[i] = 0p;
         }
 }
 
-void ^?{}( Server & mutex this ) {
-        assert(this.cnt == 0);
-        for(i; NFUTURES) {
-                this.requests[i] = 0p;
+void ^?{}( Server & mutex server ) with( server )  {
+        assert( cnt == 0 );
+        for ( i; NFUTURES ) {
+                requests[i] = 0p;
         }
 }
 
-void process( Server & this, int i ) {
-        if( this.requests[i] == 0p ) return;
-        single_future(int) * f = this.requests[i];
-        this.requests[i] = 0p;
-        this.cnt--;
-        fulfil( *f , i);
+void process( Server & server, int i ) with( server )  {
+  if ( requests[i] == 0p ) return;
+        single_future(int) * f = requests[i];
+        requests[i] = 0p;
+        cnt--;
+        (*f)( i );                                                                                      // fulfil
 }
 
-void call( Server & mutex this, single_future(int) & f ) {
-        for(i; NFUTURES) {
-                if( this.requests[i] == 0p ) {
-                        this.requests[i] = &f;
-                        this.cnt++;
+void call( Server & mutex server, single_future(int) & f ) with( server ) {
+        for ( i; NFUTURES ) {
+                if ( requests[i] == 0p ) {
+                        requests[i] = &f;
+                        cnt++;
                         return;
                 }
@@ -41 +41 @@
 }
 
-void main( Server & this ) {
+void main( Server & server ) {
         unsigned i = 0;
-        for() {
-                waitfor( ^?{} : this ) {
+        for () {
+                waitfor ( ^?{} : server ) {
                         break;
-                }
-                or when( this.cnt < NFUTURES ) waitfor( call: this ) {}
+                } or when( server.cnt < NFUTURES ) waitfor( call : server ) {}
                 or else {
-                        process( this, i % NFUTURES );
+                        process( server, i % NFUTURES );
                         i++;
                 }
         }
 
-        for(i; NFUTURES) {
-                process( this, i );
+        for ( i; NFUTURES ) {
+                process( server, i );
         }
 }
@@ -62 +61 @@
 thread Worker {};
 
-void thrash(void) {
+void thrash() {
         volatile int locals[250];
-        for(i; 250) {
+        for ( i; 250 ) {
                 locals[i] = 0xdeadbeef;
         }
 }
 
-void work(void) {
+void work() {
         single_future(int) mine;
         call( *the_server, mine );
-        wait( mine );
+        mine();                                                                                         // get
 }
 
 void main( Worker & ) {
-        for(150) {
+        for ( 150 ) {
                 thrash();
                 work();
@@ -84 +83 @@
 
 int main() {
-        printf( "start\n" );                            // non-empty .expect file
+        printf( "start\n" );                                                            // non-empty .expect file
         processor procs[2];
         {
@@ -93 +92 @@
                 }
         }
-        printf( "done\n" );                             // non-empty .expect file
-
+        printf( "done\n" );                                                                     // non-empty .expect file
 }