Changes in src/libcfa/concurrency/kernel.c [85b1deb:5510027]

File:

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

src/libcfa/concurrency/kernel.c

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