Changeset 85b1deb for src/libcfa/concurrency

Timestamp:

Jun 7, 2018, 6:10:10 PM (6 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:

7bdcac1, beefc34c

Parents:

08b5a7e

Message:

Fix processor halting

Location:

src/libcfa/concurrency

Files:

• kernel (modified) (2 diffs)
• kernel.c (modified) (7 diffs)
• kernel_private.h (modified) (2 diffs)
• preemption.c (modified) (1 diff)

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
@@ -119 +133 @@
         // Termination synchronisation
         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;
-        // __bin_sem_t idleLock;
 
         // Link lists fields

src/libcfa/concurrency/kernel.c

@@ -147 +147 @@
         runner.proc = &this;
 
-        sem_init(&idleLock, 0, 0);
+        idleLock{};
 
         start( &this );
@@ -155 +155 @@
         if( ! __atomic_load_n(&do_terminate, __ATOMIC_ACQUIRE) ) {
                 __cfaabi_dbg_print_safe("Kernel : core %p signaling termination\n", &this);
-                terminate(&this);
-                verify( __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-                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 );
 }
 
@@ -295 +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
@@ -408 +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);
+                }
+
         }
 
@@ -660 +657 @@
 
 void halt(processor * this) with( *this ) {
-        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
 
         with( *cltr ) {
@@ -671 +668 @@
         __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
 
-        // #ifdef __CFA_WITH_VERIFY__
-        //      int sval = 0;
-        //      sem_getvalue(&this->idleLock, &sval);
-        //      verifyf(sval < 200, "Binary semaphore reached value %d : \n", sval);
-        // #endif
-
-        verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
-        int __attribute__((unused)) ret = sem_wait(&idleLock);
-        // verifyf(ret >= 0 || errno == EINTR, "Sem_wait returned %d (errno %d : %s\n", ret, errno, strerror(errno));
-
-        // wait( idleLock );
+        wait( idleLock );
 
         __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
@@ -691 +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);
-        // verifyf(ret >= 0 || errno == EINTR, "Sem_post returned %d (errno %d : %s\n", ret, errno, strerror(errno));
-
-        // #ifdef __CFA_WITH_VERIFY__
-        //      int sval = 0;
-        //      sem_getvalue(&this->idleLock, &sval);
-        //      verifyf(sval < 200, "Binary semaphore reached value %d\n", sval);
-        // #endif
-
-        // post( this->idleLock );
 }
 

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

@@ -260 +260 @@
 static void preempt( processor * this ) {
         sigval_t value = { PREEMPT_NORMAL };
-        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
-}
-
-// kill wrapper : signal a processor
-void terminate(processor * this) {
-        disable_interrupts();
-        __atomic_store_n(&this->do_terminate, true, __ATOMIC_SEQ_CST);
-        wake( this );
-        sigval_t value = { PREEMPT_TERMINATE };
-        enable_interrupts( __cfaabi_dbg_ctx );
         pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }