Changes in libcfa/src/concurrency/kernel.cfa [454f478:6011658]

File:

• libcfa/src/concurrency/kernel.cfa (modified) (6 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -140 +140 @@
                 preemption_scope scope = { this };
 
-                #if !defined(__CFA_NO_STATISTICS__)
-                        unsigned long long last_tally = rdtscl();
-                #endif
-
-
                 __cfadbg_print_safe(runtime_core, "Kernel : core %p started\n", this);
 
@@ -211 +206 @@
                         // Are we done?
                         if( __atomic_load_n(&this->do_terminate, __ATOMIC_SEQ_CST) ) break MAIN_LOOP;
-
-                        #if !defined(__CFA_NO_STATISTICS__)
-                                unsigned long long curr = rdtscl();
-                                if(curr > (last_tally + 500000000)) {
-                                        __tally_stats(this->cltr->stats, __cfaabi_tls.this_stats);
-                                        last_tally = curr;
-                                }
-                        #endif
                 }
 
@@ -224 +211 @@
         }
 
-        post( this->terminated );
+        V( this->terminated );
 
         if(this == mainProcessor) {
@@ -624 +611 @@
 // Unexpected Terminating logic
 //=============================================================================================
-void __kernel_abort_msg( char * abort_text, int abort_text_size ) {
-        $thread * thrd = __cfaabi_tls.this_thread;
+static __spinlock_t kernel_abort_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 __cfaabi_dbg_ctx2 );
+
+        // disable interrupts, it no longer makes sense to try to interrupt this processor
+        disable_interrupts();
+
+        // 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
+                sigaddset( &mask, SIGUSR1 );            // 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 );
+        }
+
+        return __cfaabi_tls.this_thread;
+}
+
+void kernel_abort_msg( void * kernel_data, char * abort_text, int abort_text_size ) {
+        $thread * thrd = ( $thread * ) kernel_data;
 
         if(thrd) {
@@ -645 +662 @@
 }
 
-int __kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
-        return get_coroutine(__cfaabi_tls.this_thread) == get_coroutine(mainThread) ? 4 : 2;
+int kernel_abort_lastframe( void ) __attribute__ ((__nothrow__)) {
+        return get_coroutine(kernelTLS().this_thread) == get_coroutine(mainThread) ? 4 : 2;
 }
 
@@ -664 +681 @@
 // Kernel Utilities
 //=============================================================================================
+//-----------------------------------------------------------------------------
+// Locks
+void  ?{}( semaphore & this, int count = 1 ) {
+        (this.lock){};
+        this.count = count;
+        (this.waiting){};
+}
+void ^?{}(semaphore & this) {}
+
+bool P(semaphore & this) with( this ){
+        lock( lock __cfaabi_dbg_ctx2 );
+        count -= 1;
+        if ( count < 0 ) {
+                // queue current task
+                append( waiting, active_thread() );
+
+                // atomically release spin lock and block
+                unlock( lock );
+                park();
+                return true;
+        }
+        else {
+            unlock( lock );
+            return false;
+        }
+}
+
+bool V(semaphore & this) with( this ) {
+        $thread * thrd = 0p;
+        lock( lock __cfaabi_dbg_ctx2 );
+        count += 1;
+        if ( count <= 0 ) {
+                // remove task at head of waiting list
+                thrd = pop_head( waiting );
+        }
+
+        unlock( lock );
+
+        // make new owner
+        unpark( thrd );
+
+        return thrd != 0p;
+}
+
+bool V(semaphore & this, unsigned diff) with( this ) {
+        $thread * thrd = 0p;
+        lock( lock __cfaabi_dbg_ctx2 );
+        int release = max(-count, (int)diff);
+        count += diff;
+        for(release) {
+                unpark( pop_head( waiting ) );
+        }
+
+        unlock( lock );
+
+        return thrd != 0p;
+}
+
 //-----------------------------------------------------------------------------
 // Debug