Changeset beefc34c for src/libcfa/concurrency

Timestamp:

Jun 7, 2018, 6:12:11 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

6eb131c, 7b28e4a

Parents:

174845e (diff), 85b1deb (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:

src/libcfa/concurrency

Files:

• kernel (modified) (3 diffs)
• kernel.c (modified) (15 diffs)
• kernel_private.h (modified) (2 diffs)
• preemption.c (modified) (5 diffs)

src/libcfa/concurrency/kernel

@@ -113 +113 @@
         pthread_t kernel_thread;
 
+        // RunThread data
+        // Action to do after a thread is ran
+        struct FinishAction finish;
+
+        // Preemption data
+        // Node which is added in the discrete event simulaiton
+        struct alarm_node_t * preemption_alarm;
+
+        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
+        bool pending_preemption;
+
+        // Idle lock
+        __bin_sem_t idleLock;
+
         // Termination
         // Set to true to notify the processor should terminate
@@ -120 +134 @@
         semaphore terminated;
 
-        // RunThread data
-        // Action to do after a thread is ran
-        struct FinishAction finish;
-
-        // Preemption data
-        // Node which is added in the discrete event simulaiton
-        struct alarm_node_t * preemption_alarm;
-
-        // If true, a preemption was triggered in an unsafe region, the processor must preempt as soon as possible
-        bool pending_preemption;
-
-        // Idle lock
-        sem_t idleLock;
-
         // Link lists fields
-        struct {
+        struct __dbg_node_proc {
                 struct processor * next;
                 struct processor * prev;
@@ -182 +182 @@
 
         // Link lists fields
-        struct {
+        struct __dbg_node_cltr {
                 cluster * next;
                 cluster * prev;

src/libcfa/concurrency/kernel.c

@@ -16 +16 @@
 //C Includes
 #include <stddef.h>
+#include <errno.h>
+#include <string.h>
 extern "C" {
 #include <stdio.h>
@@ -49 +51 @@
 thread_desc * mainThread;
 
-struct { __dllist_t(cluster) list; __spinlock_t lock; } global_clusters;
+extern "C" {
+struct { __dllist_t(cluster) list; __spinlock_t lock; } __cfa_dbg_global_clusters;
+}
 
 //-----------------------------------------------------------------------------
@@ -143 +147 @@
         runner.proc = &this;
 
-        sem_init(&idleLock, 0, 0);
+        idleLock{};
 
         start( &this );
@@ -149 +153 @@
 
 void ^?{}(processor & this) with( this ){
-        if( ! do_terminate ) {
+        if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-                terminate(&this);
-                verify(this.do_terminate);
-                verify( kernelTLS.this_processor != &this);
+
+                __atomic_store_n(&do_terminate, true, __ATOMIC_RELAXED);
+                wake( &this );
+
                 P( terminated );
                 verify( kernelTLS.this_processor != &this);
-                pthread_join( kernel_thread, NULL );
-        }
-
-        sem_destroy(&idleLock);
+        }
+
+        pthread_join( kernel_thread, NULL );
 }
 
@@ -198 +202 @@
 
                 thread_desc * readyThread = NULL;
-                for( unsigned int spin_count = 0; ! this->do_terminate; spin_count++ )
+                for( unsigned int spin_count = 0; ! __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST); spin_count++ )
                 {
                         readyThread = nextThread( this->cltr );
@@ -217 +221 @@
                         else
                         {
-                                spin(this, &spin_count);
+                                // spin(this, &spin_count);
+                                halt(this);
                         }
                 }
@@ -290 +295 @@
 }
 
-// Handles spinning logic
-// TODO : find some strategy to put cores to sleep after some time
-void spin(processor * this, unsigned int * spin_count) {
-        // (*spin_count)++;
-        halt(this);
-}
-
 // KERNEL_ONLY
 // Context invoker for processors
@@ -403 +401 @@
                 unlock( ready_queue_lock );
 
-                if( was_empty ) {
+                if(was_empty) {
                         lock      (proc_list_lock __cfaabi_dbg_ctx2);
                         if(idles) {
-                                wake(idles.head);
+                                wake_fast(idles.head);
                         }
                         unlock    (proc_list_lock);
                 }
+                else if( struct processor * idle = idles.head ) {
+                        wake_fast(idle);
+                }
+
         }
 
@@ -544 +546 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
-        global_clusters.list{ __get };
-        global_clusters.lock{};
+        __cfa_dbg_global_clusters.list{ __get };
+        __cfa_dbg_global_clusters.lock{};
 
         // Initialize the main cluster
@@ -626 +628 @@
         // When its coroutine terminates, it return control to the mainThread
         // which is currently here
-        mainProcessor->do_terminate = true;
+        __atomic_store_n(&mainProcessor->do_terminate, true, __ATOMIC_RELEASE);
         returnToKernel();
+        mainThread->self_cor.state = Halted;
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
@@ -643 +646 @@
         ^(mainThread){};
 
-        ^(global_clusters.list){};
-        ^(global_clusters.lock){};
+        ^(__cfa_dbg_global_clusters.list){};
+        ^(__cfa_dbg_global_clusters.lock){};
 
         __cfaabi_dbg_print_safe("Kernel : Shutdown complete\n");
@@ -654 +657 @@
 
 void halt(processor * this) with( *this ) {
+        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+
         with( *cltr ) {
                 lock      (proc_list_lock __cfaabi_dbg_ctx2);
@@ -663 +668 @@
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
 
-        verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
-        int __attribute__((unused)) ret = sem_wait(&idleLock);
-        verify(ret > 0 || errno == EINTR);
+        wait( idleLock );
 
         __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
@@ -675 +678 @@
                 unlock    (proc_list_lock);
         }
-}
-
-void wake(processor * this) {
-        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
-        int __attribute__((unused)) ret = sem_post(&this->idleLock);
-        verify(ret > 0 || errno == EINTR);
-        verify( ({int sval = 0; sem_getvalue(&this->idleLock, &sval); sval; }) < 200);
 }
 
@@ -797 +793 @@
 // Global Queues
 void doregister( cluster     & cltr ) {
-        lock      ( global_clusters.lock __cfaabi_dbg_ctx2);
-        push_front( global_clusters.list, cltr );
-        unlock    ( global_clusters.lock );
+        lock      ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
+        push_front( __cfa_dbg_global_clusters.list, cltr );
+        unlock    ( __cfa_dbg_global_clusters.lock );
 }
 
 void unregister( cluster     & cltr ) {
-        lock  ( global_clusters.lock __cfaabi_dbg_ctx2);
-        remove( global_clusters.list, cltr );
-        unlock( global_clusters.lock );
+        lock  ( __cfa_dbg_global_clusters.lock __cfaabi_dbg_ctx2);
+        remove( __cfa_dbg_global_clusters.list, cltr );
+        unlock( __cfa_dbg_global_clusters.lock );
 }
 

src/libcfa/concurrency/kernel_private.h

@@ -58 +58 @@
 void finishRunning(processor * this);
 void halt(processor * this);
-void wake(processor * this);
-void terminate(processor * this);
-void spin(processor * this, unsigned int * spin_count);
+
+static inline void wake_fast(processor * this) {
+        __cfaabi_dbg_print_safe("Kernel : Waking up processor %p\n", this);
+        post( this->idleLock );
+}
+
+static inline void wake(processor * this) {
+        disable_interrupts();
+        wake_fast(this);
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
 
 struct event_kernel_t {
@@ -68 +76 @@
 
 extern event_kernel_t * event_kernel;
-
-//extern thread_local coroutine_desc * volatile this_coroutine;
-//extern thread_local thread_desc *    volatile this_thread;
-//extern thread_local processor *      volatile this_processor;
-
-// extern volatile thread_local bool preemption_in_progress;
-// extern volatile thread_local bool preemption_enabled;
-// extern volatile thread_local unsigned short disable_preempt_count;
 
 struct __cfa_kernel_preemption_state_t {

src/libcfa/concurrency/preemption.c

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Apr  9 13:52:39 2018
-// Update Count     : 36
+// Last Modified On : Tue Jun  5 17:35:49 2018
+// Update Count     : 37
 //
 
@@ -116 +116 @@
         // If there are still alarms pending, reset the timer
         if( alarms->head ) {
-                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%lu(%lu) resetting alarm to %lu.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
                 Duration delta = alarms->head->alarm - currtime;
                 Duration caped = max(delta, 50`us);
@@ -263 +263 @@
 }
 
-// kill wrapper : signal a processor
-void terminate(processor * this) {
-        this->do_terminate = true;
-        wake(this);
-        sigval_t value = { PREEMPT_TERMINATE };
-        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
-}
-
 // reserved for future use
 static void timeout( thread_desc * this ) {
@@ -369 +361 @@
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify( kernelTLS.this_processor->do_terminate);
+                case PREEMPT_TERMINATE: verify( __atomic_load_n( &kernelTLS.this_processor->do_terminate, __ATOMIC_SEQ_CST ) );
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -488 +480 @@
 }
 
+#ifdef __CFA_WITH_VERIFY__
+bool __cfaabi_dbg_in_kernel() {
+        return !kernelTLS.preemption_state.enabled;
+}
+#endif
+
 // Local Variables: //
 // mode: c //