Changeset 28f3a19 for src/libcfa/concurrency/kernel.c

Timestamp:

Jun 27, 2018, 3:28:41 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

b21c77a

Parents:

0182bfa (diff), 63238a4 (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' into with_gc

File:

• src/libcfa/concurrency/kernel.c (modified) (14 diffs)

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;
 
+        idleLock{};
+
         start( &this );
 }
 
 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 );
-        }
+        }
+
+        pthread_join( kernel_thread, NULL );
 }
 
@@ -194 +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 );
@@ -213 +221 @@
                         else
                         {
-                                spin(this, &spin_count);
+                                // spin(this, &spin_count);
+                                halt(this);
                         }
                 }
@@ -257 +266 @@
 // its final actions must be executed from the kernel
 void finishRunning(processor * this) with( this->finish ) {
-        if( action_code == Release ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        verify( ! kernelTLS.preemption_state.enabled );
+        choose( action_code ) {
+        case No_Action:
+                break;
+        case Release:
                 unlock( *lock );
-        }
-        else if( action_code == Schedule ) {
+        case Schedule:
                 ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Schedule ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        case Release_Schedule:
                 unlock( *lock );
                 ScheduleThread( thrd );
-        }
-        else if( action_code == Release_Multi ) {
-                verify( ! kernelTLS.preemption_state.enabled );
+        case Release_Multi:
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
                 }
-        }
-        else if( action_code == Release_Multi_Schedule ) {
+        case Release_Multi_Schedule:
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -282 +288 @@
                         ScheduleThread( thrds[i] );
                 }
-        }
-        else {
-                assert(action_code == No_Action);
-        }
-}
-
-// 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)++;
+        case Callback:
+                callback();
+        default:
+                abort("KERNEL ERROR: Unexpected action to run after thread");
+        }
 }
 
@@ -396 +397 @@
         with( *thrd->curr_cluster ) {
                 lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
+                bool was_empty = !(ready_queue != 0);
                 append( ready_queue, thrd );
                 unlock( ready_queue_lock );
+
+                if(was_empty) {
+                        lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                        if(idles) {
+                                wake_fast(idles.head);
+                        }
+                        unlock    (proc_list_lock);
+                }
+                else if( struct processor * idle = idles.head ) {
+                        wake_fast(idle);
+                }
+
         }
 
@@ -497 +511 @@
 }
 
+void BlockInternal(__finish_callback_fptr_t callback) {
+        disable_interrupts();
+        with( *kernelTLS.this_processor ) {
+                finish.action_code = Callback;
+                finish.callback    = callback;
+        }
+
+        verify( ! kernelTLS.preemption_state.enabled );
+        returnToKernel();
+        verify( ! kernelTLS.preemption_state.enabled );
+
+        enable_interrupts( __cfaabi_dbg_ctx );
+}
+
 // KERNEL ONLY
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
@@ -518 +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
@@ -600 +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
@@ -617 +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");
@@ -627 +656 @@
 //=============================================================================================
 
-// void halt(processor * this) with( this ) {
-//      pthread_mutex_lock( &idle.lock );
-
-
-
-//      // SKULLDUGGERY: Even if spurious wake-up is a thing
-//      // spuriously waking up a kernel thread is not a big deal
-//      // if it is very rare.
-//      pthread_cond_wait( &idle.cond, &idle.lock);
-//      pthread_mutex_unlock( &idle.lock );
-// }
-
-// void wake(processor * this) with( this ) {
-//      pthread_mutex_lock  (&idle.lock);
-//      pthread_cond_signal (&idle.cond);
-//      pthread_mutex_unlock(&idle.lock);
-// }
+void halt(processor * this) with( *this ) {
+        // verify( ! __atomic_load_n(&do_terminate, __ATOMIC_SEQ_CST) );
+
+        with( *cltr ) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (procs, *this);
+                push_front(idles, *this);
+                unlock    (proc_list_lock);
+        }
+
+        __cfaabi_dbg_print_safe("Kernel : Processor %p ready to sleep\n", this);
+
+        wait( idleLock );
+
+        __cfaabi_dbg_print_safe("Kernel : Processor %p woke up and ready to run\n", this);
+
+        with( *cltr ) {
+                lock      (proc_list_lock __cfaabi_dbg_ctx2);
+                remove    (idles, *this);
+                push_front(procs, *this);
+                unlock    (proc_list_lock);
+        }
+}
 
 //=============================================================================================
@@ -758 +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 );
 }