Changeset ffec1bf for libcfa/src

Timestamp:

Jul 25, 2022, 2:23:28 PM (3 years ago)

Author:

Fangren Yu <f37yu@…>

Branches:

ADT, ast-experimental, master, pthread-emulation, qualifiedEnum

Children:

4c48be0, 5cf1228, def751f

Parents:

9e23b446 (diff), 1f950c3b (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

Location:

libcfa/src

Files:

• Makefile.am (modified) (2 diffs)
• concurrency/kernel/fwd.hfa (modified) (2 diffs)
• concurrency/locks.cfa (modified) (6 diffs)
• concurrency/locks.hfa (modified) (6 diffs)
• concurrency/ready_subqueue.hfa (modified) (1 diff)
• heap.cfa (modified) (1 diff)

libcfa/src/Makefile.am

@@ -216 +216 @@
 nobase_cfa_include_HEADERS = ${stdhdr} ${inst_headers_src} ${inst_headers_nosrc} ${inst_thread_headers_src} ${inst_thread_headers_nosrc}
 EXTRA_DIST = stdhdr
+DISTCLEANFILES = $(libdeps) $(thread_libdeps)
 
 #----------------------------------------------------------------------------------------------------------------
@@ -221 +222 @@
         -rm -rf ${CFA_INCDIR} ${CFA_LIBDIR}
 
-distclean-local:
-        find ${builddir} -path '*.Plo' -delete
+#distclean-local:
+#       find ${builddir} -path '*.Plo' -delete
 
 

libcfa/src/concurrency/kernel/fwd.hfa

@@ -254 +254 @@
                         // intented to be use by wait, wait_any, waitfor, etc. rather than used directly
                         bool setup( future_t & this, oneshot & wait_ctx ) {
-                                /* paranoid */ verify( wait_ctx.ptr == 0p );
+                                /* paranoid */ verify( wait_ctx.ptr == 0p || wait_ctx.ptr == 1p );
                                 // The future needs to set the wait context
                                 for() {
@@ -274 +274 @@
                         // intented to be use by wait, wait_any, waitfor, etc. rather than used directly
                         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");
-
+                                struct oneshot * expected = this.ptr;
+
+                                // 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)) {
                                         // 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;
-                                        }
-                                }
+                                        return false;
+                                }
+
+                                // 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;
+                                }
+
+                                // anything else: the future was setup with a different context ?!?!
+                                // something went wrong here, abort
+                                abort("Future in unexpected state");
                         }
 

libcfa/src/concurrency/locks.cfa

@@ -237 +237 @@
                 // This pthread_cond_var member is called from the kernel, and therefore, cannot block, but it can spin.
                 lock( cond->lock __cfaabi_dbg_ctx2 );
-
                 // this check is necessary to avoid a race condition since this timeout handler
                 //      may still be called after a thread has been removed from the queue but
@@ -347 +346 @@
                 size_t recursion_count = queue_and_get_recursion(this, &info);
                 alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
+                unlock( lock );
+
+                // registers alarm outside cond lock to avoid deadlock
                 register_self( &node_wrap.alarm_node );
-                unlock( lock );
 
                 // blocks here
@@ -437 +438 @@
                 if ( ret ) {
                         info_thread(L) & popped = try_pop_front( blocked_threads );
+                        popped.signalled = true;
                         on_notify(*popped.lock, popped.t);
                 }
@@ -448 +450 @@
                 while( ! blocked_threads`isEmpty ) {
                         info_thread(L) & popped = try_pop_front( blocked_threads );
+                        popped.signalled = true;
                         on_notify(*popped.lock, popped.t);
                 }
@@ -469 +472 @@
                 size_t recursion_count = queue_and_get_recursion(this, &info);
                 pthread_alarm_node_wrap(L) node_wrap = { t, 0`s, callback, &this, &info };
+                unlock( lock );
+
+                // registers alarm outside cond lock to avoid deadlock
                 register_self( &node_wrap.alarm_node );
-                unlock( lock );
 
                 // blocks here
@@ -500 +505 @@
                 return i.signalled;
 
+        Duration getDuration(timespec t) {
+                timespec currTime;
+                clock_gettime(CLOCK_REALTIME, &currTime);
+                Duration waitUntil = { t };
+                Duration currDur = { currTime };
+                if ( currDur >= waitUntil ) return currDur - waitUntil;
+                Duration zero = { 0 };
+                return zero;
+        }
+
         bool wait( pthread_cond_var(L) & this, L & l, timespec t ) {
-                Duration d = { t };
-                WAIT_TIME( 0, &l , d )
+                PTHREAD_WAIT_TIME( 0, &l , getDuration( t ) )
         }
         
         bool wait( pthread_cond_var(L) & this, L & l, uintptr_t info, timespec t  ) {
-                Duration d = { t };
-                WAIT_TIME( info, &l , d )
+                PTHREAD_WAIT_TIME( info, &l , getDuration( t ) )
         }
 }

libcfa/src/concurrency/locks.hfa

@@ -478 +478 @@
         #endif
         lock( lock, node );
-        while(held) Pause();
-        held = true;
-        // printf("locked\n");
+        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
+        __atomic_store_n(&held, true, __ATOMIC_SEQ_CST);
         unlock( lock, node );
         #ifdef __CFA_DEBUG__
@@ -488 +487 @@
 
 static inline void unlock(spin_queue_lock & this) with(this) {
-        // printf("unlocked\n");
         #ifdef __CFA_DEBUG__
         owner = 0p;
         #endif
-        held = false;
+        __atomic_store_n(&held, false, __ATOMIC_RELEASE);
 }
 
@@ -535 +533 @@
         #endif
         lock( lock, node );
-        while(held) Pause();
-        held = true;
+        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
+        __atomic_store_n(&held, true, __ATOMIC_SEQ_CST);
         unlock( lock, node );
         #ifdef __CFA_DEBUG__
@@ -547 +545 @@
         owner = 0p;
         #endif
-        held = false;
+        __atomic_store_n(&held, false, __ATOMIC_SEQ_CST);
 }
 
@@ -588 +586 @@
         #endif
         lock( lock );
-        while(held) Pause();
-        held = true;
+        while(__atomic_load_n(&held, __ATOMIC_SEQ_CST)) Pause();
+        __atomic_store_n(&held, true, __ATOMIC_RELEASE);
         unlock( lock );
         #ifdef __CFA_DEBUG__
@@ -600 +598 @@
         owner = 0p;
         #endif
-        held = false;
+        __atomic_store_n(&held, false, __ATOMIC_RELEASE);
 }
 

libcfa/src/concurrency/ready_subqueue.hfa

@@ -49 +49 @@
         // Get the relevant nodes locally
         this.prev->link.next = node;
-        this.prev->link.ts   = rdtscl();
+        __atomic_store_n(&this.prev->link.ts, rdtscl(), __ATOMIC_RELAXED);
         this.prev = node;
         #if !defined(__CFA_NO_STATISTICS__)

libcfa/src/heap.cfa

@@ -509 +509 @@
         checkHeader( header < (Heap.Storage.Header *)heapBegin || (Heap.Storage.Header *)heapEnd < header, name, addr ); // bad address ? (offset could be + or -)
 
-        Heap * homeManager;
         if ( unlikely( freeHead == 0p || // freed and only free-list node => null link
                                    // freed and link points at another free block not to a bucket in the bucket array.