Changes in src/libcfa/concurrency/kernel.c [afd550c:de94a60]

File:

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

src/libcfa/concurrency/kernel.c

@@ -49 +49 @@
 thread_desc * mainThread;
 
+struct { __dllist_t(thread_desc) list; __spinlock_t lock; } global_threads ;
+struct { __dllist_t(cluster    ) list; __spinlock_t lock; } global_clusters;
+
 //-----------------------------------------------------------------------------
 // Global state
@@ -117 +120 @@
         self_mon_p = &self_mon;
         next = NULL;
-        __cfaabi_dbg_debug_do(
-                dbg_next = NULL;
-                dbg_prev = NULL;
-                __cfaabi_dbg_thread_register(&this);
-        )
+
+        node.next = NULL;
+        node.prev = NULL;
+        doregister(this);
 
         monitors{ &self_mon_p, 1, (fptr_t)0 };
@@ -167 +169 @@
         ready_queue{};
         ready_queue_lock{};
+
+        procs{ __get };
+        idles{ __get };
+
+        doregister(this);
 }
 
 void ^?{}(cluster & this) {
-
+        unregister(this);
 }
 
@@ -182 +189 @@
 
         __cfaabi_dbg_print_safe("Kernel : core %p starting\n", this);
+
+        doregister(this->cltr, this);
 
         {
@@ -215 +224 @@
                 __cfaabi_dbg_print_safe("Kernel : core %p stopping\n", this);
         }
+
+        unregister(this->cltr, this);
 
         V( this->terminated );
@@ -512 +523 @@
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
+        global_threads. list{ __get };
+        global_threads. lock{};
+        global_clusters.list{ __get };
+        global_clusters.lock{};
+
         // Initialize the main cluster
         mainCluster = (cluster *)&storage_mainCluster;
@@ -639 +655 @@
 
 static __spinlock_t kernel_abort_lock;
-static __spinlock_t kernel_debug_lock;
 static bool kernel_abort_called = false;
 
@@ -648 +663 @@
 
         // first task to abort ?
-        if ( ! kernel_abort_called ) {                  // not first task to abort ?
+        if ( kernel_abort_called ) {                    // not first task to abort ?
+                unlock( kernel_abort_lock );
+
+                sigset_t mask;
+                sigemptyset( &mask );
+                sigaddset( &mask, SIGALRM );            // block SIGALRM signals
+                sigsuspend( &mask );                    // block the processor to prevent further damage during abort
+                _exit( EXIT_FAILURE );                  // if processor unblocks before it is killed, terminate it
+        }
+        else {
                 kernel_abort_called = true;
                 unlock( kernel_abort_lock );
         }
-        else {
-                unlock( kernel_abort_lock );
-
-                sigset_t mask;
-                sigemptyset( &mask );
-                sigaddset( &mask, SIGALRM );                    // block SIGALRM signals
-                sigaddset( &mask, SIGUSR1 );                    // block SIGUSR1 signals
-                sigsuspend( &mask );                            // block the processor to prevent further damage during abort
-                _exit( EXIT_FAILURE );                          // if processor unblocks before it is killed, terminate it
-        }
 
         return kernelTLS.this_thread;
@@ -669 +683 @@
         thread_desc * thrd = kernel_data;
 
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->self_cor.name, thrd );
-        __cfaabi_dbg_bits_write( abort_text, len );
-
-        if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
-                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+        if(thrd) {
+                int len = snprintf( abort_text, abort_text_size, "Error occurred while executing thread %.256s (%p)", thrd->self_cor.name, thrd );
                 __cfaabi_dbg_bits_write( abort_text, len );
+
+                if ( get_coroutine(thrd) != kernelTLS.this_coroutine ) {
+                        len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", kernelTLS.this_coroutine->name, kernelTLS.this_coroutine );
+                        __cfaabi_dbg_bits_write( abort_text, len );
+                }
+                else {
+                        __cfaabi_dbg_bits_write( ".\n", 2 );
+                }
         }
         else {
-                __cfaabi_dbg_bits_write( ".\n", 2 );
+                int len = snprintf( abort_text, abort_text_size, "Error occurred outside of any thread.\n" );
         }
 }
@@ -684 +703 @@
         return get_coroutine(kernelTLS.this_thread) == get_coroutine(mainThread) ? 4 : 2;
 }
+
+static __spinlock_t kernel_debug_lock;
 
 extern "C" {
@@ -738 +759 @@
 
 //-----------------------------------------------------------------------------
+// Global Queues
+void doregister( thread_desc & thrd ) {
+        // lock      ( global_thread.lock );
+        // push_front( global_thread.list, thrd );
+        // unlock    ( global_thread.lock );
+}
+
+void unregister( thread_desc & thrd ) {
+        // lock  ( global_thread.lock );
+        // remove( global_thread.list, thrd );
+        // unlock( global_thread.lock );
+}
+
+void doregister( cluster     & cltr ) {
+        // lock      ( global_cluster.lock );
+        // push_front( global_cluster.list, cltr );
+        // unlock    ( global_cluster.lock );
+}
+
+void unregister( cluster     & cltr ) {
+        // lock  ( global_cluster.lock );
+        // remove( global_cluster.list, cltr );
+        // unlock( global_cluster.lock );
+}
+
+
+void doregister( cluster * cltr, processor * proc ) {
+        // lock      (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // push_front(cltr->procs, *proc);
+        // unlock    (cltr->proc_list_lock);
+}
+
+void unregister( cluster * cltr, processor * proc ) {
+        // lock  (cltr->proc_list_lock __cfaabi_dbg_ctx2);
+        // remove(cltr->procs, *proc );
+        // unlock(cltr->proc_list_lock);
+}
+
+//-----------------------------------------------------------------------------
 // Debug
 __cfaabi_dbg_debug_do(
-        struct {
-                thread_desc * tail;
-        } __cfaabi_dbg_thread_list = { NULL };
-
-        void __cfaabi_dbg_thread_register( thread_desc * thrd ) {
-                if( !__cfaabi_dbg_thread_list.tail ) {
-                        __cfaabi_dbg_thread_list.tail = thrd;
-                        return;
-                }
-                __cfaabi_dbg_thread_list.tail->dbg_next = thrd;
-                thrd->dbg_prev = __cfaabi_dbg_thread_list.tail;
-                __cfaabi_dbg_thread_list.tail = thrd;
-        }
-
-        void __cfaabi_dbg_thread_unregister( thread_desc * thrd ) {
-                thread_desc * prev = thrd->dbg_prev;
-                thread_desc * next = thrd->dbg_next;
-
-                if( next ) { next->dbg_prev = prev; }
-                else       {
-                        assert( __cfaabi_dbg_thread_list.tail == thrd );
-                        __cfaabi_dbg_thread_list.tail = prev;
-                }
-
-                if( prev ) { prev->dbg_next = next; }
-
-                thrd->dbg_prev = NULL;
-                thrd->dbg_next = NULL;
-        }
-
         void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
                 this.prev_name = prev_name;