Changeset c9d36b1 for libcfa/src

Timestamp:

Feb 14, 2026, 10:38:00 PM (6 days ago)

Author:

Matthew Au-Yeung <mw2auyeu@…>

Branches:

stuck-waitfor-destruct

Children:

a56d544

Parents:

bbcc492

git-author:

Matthew Au-Yeung <mw2auyeu@…> (02/07/26 13:40:05)

git-committer:

Matthew Au-Yeung <mw2auyeu@…> (02/14/26 22:38:00)

Message:

Add a generated hash to fix stuck waitfor comparing static inline mutex destructors

Location:

libcfa/src

Files:

• bits/defs.hfa (modified) (1 diff)
• concurrency/invoke.h (modified) (4 diffs)
• concurrency/kernel/startup.cfa (modified) (1 diff)
• concurrency/monitor.cfa (modified) (7 diffs)
• concurrency/monitor.hfa (modified) (2 diffs)
• concurrency/thread.cfa (modified) (4 diffs)
• concurrency/thread.hfa (modified) (1 diff)

libcfa/src/bits/defs.hfa

@@ -26 +26 @@
 
 typedef void (* fptr_t)();
+typedef uint64_t func_id_t;
 typedef int_fast16_t __lock_size_t;
 

libcfa/src/concurrency/invoke.h

@@ -159 +159 @@
                 // last function that acquired monitors
                 fptr_t func;
+
+                // hash-based function identity for cross-TU matching
+                func_id_t func_id;
         };
 
@@ -288 +291 @@
                         (this.size){0};
                         (this.func){NULL};
-                }
-
-                static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func) {
+                        (this.func_id){0};
+                }
+
+                static inline void ?{}(__monitor_group_t & this, struct monitor$ ** data, __lock_size_t size, fptr_t func, func_id_t func_id) {
                         (this.data){data};
                         (this.size){size};
                         (this.func){func};
+                        (this.func_id){func_id};
                 }
 
@@ -299 +304 @@
                         if( (lhs.data != 0) != (rhs.data != 0) ) return false;
                         if( lhs.size != rhs.size ) return false;
-                        if( lhs.func != rhs.func ) return false;
+                        // Use hash-based comparison when both sides have a valid func_id,
+                        // otherwise fall back to function pointer comparison (for library code
+                        // like join() that cannot compute the hash at compile time).
+                        if( lhs.func_id != 0 && rhs.func_id != 0 ) {
+                                if( lhs.func_id != rhs.func_id ) return false;
+                        } else {
+                                if( lhs.func != rhs.func ) return false;
+                        }
 
                         // Check that all the monitors match
@@ -314 +326 @@
                         lhs.size = rhs.size;
                         lhs.func = rhs.func;
+                        lhs.func_id = rhs.func_id;
                 }
         }

libcfa/src/concurrency/kernel/startup.cfa

@@ -517 +517 @@
         doregister(curr_cluster, this);
 
-        monitors{ &self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0, (func_id_t)0 };
 }
 

libcfa/src/concurrency/monitor.cfa

@@ -140 +140 @@
 }
 
-static void __dtor_enter( monitor$ * this, fptr_t func, bool join ) {
+static void __dtor_enter( monitor$ * this, fptr_t func, func_id_t func_id, bool join ) {
         thread$ * thrd = active_thread();
         #if defined( __CFA_WITH_VERIFY__ )
@@ -190 +190 @@
         __lock_size_t count = 1;
         monitor$ ** monitors = &this;
-        __monitor_group_t group = { &this, 1, func };
+        __monitor_group_t group = { &this, 1, func, func_id };
         if ( is_accepted( this, group) ) {
                 __cfaabi_dbg_print_safe( "Kernel : mon accepts dtor, block and signal it \n" );
@@ -341 +341 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func ) libcfa_public {
+void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count, fptr_t func, func_id_t func_id ) libcfa_public {
         thread$ * thrd = active_thread();
 
@@ -355 +355 @@
 
         // Update thread context (needed for conditions)
-        (thrd->monitors){m, count, func};
+        (thrd->monitors){m, count, func, func_id};
 
         // __cfaabi_dbg_print_safe( "MGUARD : enter %d\n", count);
 
         // Enter the monitors in order
-        __monitor_group_t group = {this.m, this.count, func};
+        __monitor_group_t group = {this.m, this.count, func, func_id};
         enter( group );
 
@@ -367 +367 @@
 
 void ?{}( monitor_guard_t & this, monitor$ * m [], __lock_size_t count ) libcfa_public {
-        this{ m, count, 0p };
+        this{ m, count, 0p, 0 };
 }
 
@@ -386 +386 @@
 // Ctor for monitor guard
 // Sorts monitors before entering
-void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, bool join ) libcfa_public {
+void ?{}( monitor_dtor_guard_t & this, monitor$ * m [], fptr_t func, func_id_t func_id, bool join ) libcfa_public {
         // optimization
         thread$ * thrd = active_thread();
@@ -400 +400 @@
 
         // Update thread context (needed for conditions)
-        (thrd->monitors){m, 1, func};
-
-        __dtor_enter( this.m, func, join );
+        (thrd->monitors){m, 1, func, func_id};
+
+        __dtor_enter( this.m, func, func_id, join );
 }
 

libcfa/src/concurrency/monitor.hfa

@@ -48 +48 @@
 };
 
-void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)() );
+void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count, void (*func)(), func_id_t func_id );
 void ?{}( monitor_guard_t & this, monitor$ ** m, __lock_size_t count );
 void ^?{}( monitor_guard_t & this );
@@ -58 +58 @@
 };
 
-void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), bool join );
+void ?{}( monitor_dtor_guard_t & this, monitor$ ** m, void (*func)(), func_id_t func_id, bool join );
 void ^?{}( monitor_dtor_guard_t & this );
 

libcfa/src/concurrency/thread.cfa

@@ -61 +61 @@
 
         doregister(curr_cluster, this);
-        monitors{ &self_mon_p, 1, (fptr_t)0 };
+        monitors{ &self_mon_p, 1, (fptr_t)0, (func_id_t)0 };
 }
 
@@ -93 +93 @@
     | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 void ?{}( thread_dtor_guard_t & this,
-                T & thrd, void(*cancelHandler)(ThreadCancelled(T) &)) {
+                T & thrd, func_id_t func_id, void(*cancelHandler)(ThreadCancelled(T) &)) {
         monitor$ * m = get_monitor(thrd);
         thread$ * desc = get_thread(thrd);
@@ -100 +100 @@
         void (*dtor)(T& mutex this) = ^?{};
         bool join = cancelHandler != (void(*)(ThreadCancelled(T)&))0;
-        (this.mg){&m, (void(*)())dtor, join};
+        this.func_id = func_id;
+        (this.mg){&m, (void(*)())dtor, func_id, join};
 
 
@@ -172 +173 @@
         | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
 T & join( T & this ) {
-        thread_dtor_guard_t guard = { this, defaultResumptionHandler };
+        thread_dtor_guard_t guard = { this, (func_id_t)0, defaultResumptionHandler };
         return this;
 }

libcfa/src/concurrency/thread.hfa

@@ -83 +83 @@
 struct thread_dtor_guard_t {
         monitor_dtor_guard_t mg;
+        func_id_t func_id;
 };
 
 forall( T & | is_thread(T) | IS_EXCEPTION(ThreadCancelled(T))
         | { EHM_DEFAULT_VTABLE(ThreadCancelled(T)); })
-void ?{}( thread_dtor_guard_t & this, T & thrd, void(*)(ThreadCancelled(T) &) );
+void ?{}( thread_dtor_guard_t & this, T & thrd, func_id_t func_id, void(*)(ThreadCancelled(T) &) );
 void ^?{}( thread_dtor_guard_t & this );