Changeset 00aa122 for libcfa/src/concurrency/future.hfa

Timestamp:

Nov 24, 2025, 4:13:37 PM (20 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

File:

• libcfa/src/concurrency/future.hfa (modified) (4 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 )