Changes in src/libcfa/concurrency/kernel.c [9d944b2:17af7d1]

File:

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

src/libcfa/concurrency/kernel.c

@@ -15 +15 @@
 //
 
-#include "startup.h"
-
 //Start and stop routine for the kernel, declared first to make sure they run first
-void kernel_startup(void)  __attribute__(( constructor( STARTUP_PRIORITY_KERNEL ) ));
-void kernel_shutdown(void) __attribute__(( destructor ( STARTUP_PRIORITY_KERNEL ) ));
+void kernel_startup(void)  __attribute__((constructor(101)));
+void kernel_shutdown(void) __attribute__((destructor(101)));
 
 //Header
@@ -27 +25 @@
 #include <stddef.h>
 extern "C" {
-#include <stdio.h>
 #include <fenv.h>
 #include <sys/resource.h>
-#include <signal.h>
-#include <unistd.h>
 }
 
@@ -151 +146 @@
 
         this->runner = runner;
-        LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
+        LIB_DEBUG_PRINTF("Kernel : constructing processor context %p\n", runner);
         runner{ this };
 }
@@ -157 +152 @@
 void ^?{}(processor * this) {
         if( ! this->is_terminated ) {
-                LIB_DEBUG_PRINT_SAFE("Kernel : core %p signaling termination\n", this);
+                LIB_DEBUG_PRINTF("Kernel : core %p signaling termination\n", this);
                 this->is_terminated = true;
                 wait( &this->terminated );
@@ -178 +173 @@
 void main(processorCtx_t * runner) {
         processor * this = runner->proc;
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p starting\n", this);
+        LIB_DEBUG_PRINTF("Kernel : core %p starting\n", this);
 
         thread_desc * readyThread = NULL;
@@ -200 +195 @@
         }
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p unlocking thread\n", this);
+        LIB_DEBUG_PRINTF("Kernel : core %p unlocking thread\n", this);
         signal( &this->terminated );
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p terminated\n", this);
+        LIB_DEBUG_PRINTF("Kernel : core %p terminated\n", this);
 }
 
@@ -260 +255 @@
         processorCtx_t proc_cor_storage = { proc, &info };
 
-        LIB_DEBUG_PRINT_SAFE("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
+        LIB_DEBUG_PRINTF("Coroutine : created stack %p\n", proc_cor_storage.__cor.stack.base);
 
         //Set global state
@@ -267 +262 @@
 
         //We now have a proper context from which to schedule threads
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
+        LIB_DEBUG_PRINTF("Kernel : core %p created (%p, %p)\n", proc, proc->runner, &ctx);
 
         // SKULLDUGGERY: Since the coroutine doesn't have its own stack, we can't 
@@ -278 +273 @@
 
         // Main routine of the core returned, the core is now fully terminated
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p main ended (%p)\n", proc, proc->runner); 
+        LIB_DEBUG_PRINTF("Kernel : core %p main ended (%p)\n", proc, proc->runner);     
 
         return NULL;
@@ -284 +279 @@
 
 void start(processor * this) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
+        LIB_DEBUG_PRINTF("Kernel : Starting core %p\n", this);
         
         // pthread_attr_t attributes;
@@ -293 +288 @@
         // pthread_attr_destroy( &attributes );
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
+        LIB_DEBUG_PRINTF("Kernel : core %p started\n", this);   
 }
 
@@ -339 +334 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Starting\n");    
+        LIB_DEBUG_PRINTF("Kernel : Starting\n");        
 
         // Start by initializing the main thread
@@ -374 +369 @@
 
         // THE SYSTEM IS NOW COMPLETELY RUNNING
-        LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
+        LIB_DEBUG_PRINTF("Kernel : Started\n--------------------------------------------------\n\n");
 }
 
 void kernel_shutdown(void) {
-        LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
+        LIB_DEBUG_PRINTF("\n--------------------------------------------------\nKernel : Shutting down\n");
 
         // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
@@ -397 +392 @@
         ^(mainThread){};
 
-        LIB_DEBUG_PRINT_SAFE("Kernel : Shutdown complete\n");   
-}
-
-static spinlock kernel_abort_lock;
-static spinlock kernel_debug_lock;
-static bool kernel_abort_called = false;
-
-void * kernel_abort    (void) __attribute__ ((__nothrow__)) {
-        // abort cannot be recursively entered by the same or different processors because all signal handlers return when
-        // the globalAbort flag is true.
-        lock( &kernel_abort_lock );
-
-        // first task to abort ?
-        if ( !kernel_abort_called ) {                   // not first task to abort ?
-                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 this_thread();
-}
-
-void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
-        thread_desc * thrd = kernel_data;
-
-        int len = snprintf( abort_text, abort_text_size, "Error occurred while executing task %.256s (%p)", thrd->cor.name, thrd );
-        __lib_debug_write( STDERR_FILENO, abort_text, len );
-
-        if ( thrd != this_coroutine() ) {
-                len = snprintf( abort_text, abort_text_size, " in coroutine %.256s (%p).\n", this_coroutine()->name, this_coroutine() );
-                __lib_debug_write( STDERR_FILENO, abort_text, len );
-        } 
-        else {
-                __lib_debug_write( STDERR_FILENO, ".\n", 2 );
-        }
-}
-
-extern "C" {
-        void __lib_debug_acquire() {
-                lock(&kernel_debug_lock);
-        }
-
-        void __lib_debug_release() {
-                unlock(&kernel_debug_lock);
-        }
+        LIB_DEBUG_PRINTF("Kernel : Shutdown complete\n");       
 }