Changes in / [1a18423:e9a3b20b]

Location:

src

Files:

• benchmark/interrupt_linux.c (deleted)
• libcfa/concurrency/alarm.c (modified) (8 diffs)
• libcfa/concurrency/coroutine.c (modified) (1 diff)
• libcfa/concurrency/invoke.c (modified) (2 diffs)
• libcfa/concurrency/kernel (modified) (1 diff)
• libcfa/concurrency/kernel.c (modified) (15 diffs)
• libcfa/concurrency/kernel_private.h (modified) (2 diffs)
• libcfa/concurrency/monitor.c (modified) (7 diffs)
• libcfa/concurrency/preemption.c (modified) (10 diffs)
• libcfa/concurrency/thread.c (modified) (2 diffs)
• libcfa/libhdr/libdebug.h (modified) (1 diff)

src/libcfa/concurrency/alarm.c

@@ -16 +16 @@
 
 extern "C" {
-#include <errno.h>
-#include <stdio.h>
-#include <string.h>
 #include <time.h>
-#include <unistd.h>
 #include <sys/time.h>
 }
@@ -26 +22 @@
 #include "alarm.h"
 #include "kernel_private.h"
-#include "libhdr.h"
 #include "preemption.h"
 
@@ -36 +31 @@
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
-        __cfa_time_t curr_time = ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Kernel : current time is %lu\n", curr_time );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-        return curr_time;
+        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
 }
 
 void __kernel_set_timer( __cfa_time_t alarm ) {
-
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Kernel : set timer to %lu\n", (__cfa_time_t)alarm );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
         itimerval val;
         val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
@@ -89 +71 @@
 }
 
-LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
-        alarm_node_t ** it = &this->head;
-        while( (*it) ) {
-                it = &(*it)->next;
-        }
-
-        return it == this->tail;
-})
-
 static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {
-        verify( !n->next );
+        assert( !n->next );
         if( p == this->tail ) {
                 this->tail = &n->next;
@@ -107 +80 @@
         }
         *p = n;
-
-        verify( validate( this ) );
 }
 
@@ -118 +89 @@
 
         insert_at( this, n, it );
-
-        verify( validate( this ) );
 }
 
@@ -131 +100 @@
                 head->next = NULL;
         }
-        verify( validate( this ) );
         return head;
 }
@@ -137 +105 @@
 static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
         verify( it );
-        verify( (*it) == n );
+        verify( (*it)->next == n );
 
-        (*it) = n->next;
+        (*it)->next = n->next;
         if( !n-> next ) {
                 this->tail = it;
         }
         n->next = NULL;
-
-        verify( validate( this ) );
 }
 
 static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
         alarm_node_t ** it = &this->head;
-        while( (*it) && (*it) != n ) {
+        while( (*it) && (*it)->next != n ) {
                 it = &(*it)->next;
         }
 
-        verify( validate( this ) );
-
         if( *it ) { remove_at( this, n, it ); }
-
-        verify( validate( this ) );
 }
 
 void register_self( alarm_node_t * this ) {
         disable_interrupts();
-        verify( !systemProcessor->pending_alarm );
+        assert( !systemProcessor->pending_alarm );
         lock( &systemProcessor->alarm_lock );
         {
-                verify( validate( &systemProcessor->alarms ) );
-                bool first = !systemProcessor->alarms.head;
-
                 insert( &systemProcessor->alarms, this );
                 if( systemProcessor->pending_alarm ) {
                         tick_preemption();
                 }
-                if( first ) {
-                        __kernel_set_timer( systemProcessor->alarms.head->alarm - __kernel_get_time() );
-                }
         }
         unlock( &systemProcessor->alarm_lock );
         this->set = true;
-        enable_interrupts( __PRETTY_FUNCTION__ );
+        enable_interrupts();
 }
 
 void unregister_self( alarm_node_t * this ) {
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Kernel : unregister %p start\n", this );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
         disable_interrupts();
         lock( &systemProcessor->alarm_lock );
-        {
-                verify( validate( &systemProcessor->alarms ) );
-                remove( &systemProcessor->alarms, this );
-        }
+        remove( &systemProcessor->alarms, this );
         unlock( &systemProcessor->alarm_lock );
         disable_interrupts();
         this->set = false;
-        LIB_DEBUG_DO(
-                len = snprintf( text, 256, "Kernel : unregister %p end\n", this );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
 }

src/libcfa/concurrency/coroutine.c

@@ -32 +32 @@
 #include "invoke.h"
 
-extern volatile thread_local processor * this_processor;
+extern thread_local processor * this_processor;
 
 //-----------------------------------------------------------------------------

src/libcfa/concurrency/invoke.c

@@ -30 +30 @@
 extern void __suspend_internal(void);
 extern void __leave_monitor_desc( struct monitor_desc * this );
-extern void disable_interrupts();
-extern void enable_interrupts( const char * );
 
 void CtxInvokeCoroutine(
@@ -69 +67 @@
       struct monitor_desc* mon = &thrd->mon;
       cor->state = Active;
-      enable_interrupts( __PRETTY_FUNCTION__ );
 
       // LIB_DEBUG_PRINTF("Invoke Thread : invoking main %p (args %p)\n", main, this);
       main( this );
 
-      disable_interrupts();
       __leave_monitor_desc( mon );
 

src/libcfa/concurrency/kernel

@@ -90 +90 @@
         unsigned int preemption;
 
+        unsigned short disable_preempt_count;
+
         bool pending_preemption;
-
-        char * last_enable;
 };
 

src/libcfa/concurrency/kernel.c

@@ -59 +59 @@
 // Global state
 
-volatile thread_local processor * this_processor;
-volatile thread_local unsigned short disable_preempt_count;
+thread_local processor * this_processor;
 
 coroutine_desc * this_coroutine(void) {
@@ -143 +142 @@
         this->preemption_alarm = NULL;
         this->preemption = default_preemption();
+        this->disable_preempt_count = 1;                //Start with interrupts disabled
         this->pending_preemption = false;
 
@@ -154 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
-        this->preemption_alarm = NULL;
-        this->preemption = default_preemption();
+        this->disable_preempt_count = 0;
         this->pending_preemption = false;
-        this->kernel_thread = pthread_self();
 
         this->runner = runner;
-        LIB_DEBUG_PRINT_SAFE("Kernel : constructing system processor context %p\n", runner);
+        LIB_DEBUG_PRINT_SAFE("Kernel : constructing processor context %p\n", runner);
         runner{ this };
 }
-
-LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
 
 void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) {
@@ -172 +168 @@
 
         (&this->proc){ cltr, runner };
-
-        verify( validate( &this->alarms ) );
 }
 
@@ -215 +209 @@
                         if(readyThread)
                         {
-                                verify( disable_preempt_count > 0 );
-
                                 runThread(this, readyThread);
-
-                                verify( disable_preempt_count > 0 );
 
                                 //Some actions need to be taken from the kernel
@@ -299 +289 @@
         processor * proc = (processor *) arg;
         this_processor = proc;
-        disable_preempt_count = 1;
         // SKULLDUGGERY: We want to create a context for the processor coroutine
         // which is needed for the 2-step context switch. However, there is no reason
@@ -333 +322 @@
 void start(processor * this) {
         LIB_DEBUG_PRINT_SAFE("Kernel : Starting core %p\n", this);
-
-        // SIGALRM must only be caught by the system processor
-        sigset_t old_mask;
-        bool is_system_proc = this_processor == &systemProcessor->proc;
-        if ( is_system_proc ) {
-                // Child kernel-thread inherits the signal mask from the parent kernel-thread. So one special case for the
-                // system processor creating the user processor => toggle the blocking SIGALRM on system processor, create user
-                // processor, and toggle back (below) previous signal mask of the system processor.
-
-                sigset_t new_mask;
-                sigemptyset( &new_mask );
-                sigemptyset( &old_mask );
-                sigaddset( &new_mask, SIGALRM );
-
-                if ( sigprocmask( SIG_BLOCK, &new_mask, &old_mask ) == -1 ) {
-                        abortf( "internal error, sigprocmask" );
-                }
-
-                assert( ! sigismember( &old_mask, SIGALRM ) );
-        }
-
+        
         pthread_create( &this->kernel_thread, NULL, CtxInvokeProcessor, (void*)this );
-
-        // Toggle back previous signal mask of system processor.
-        if ( is_system_proc ) {
-                if ( sigprocmask( SIG_SETMASK, &old_mask, NULL ) == -1 ) {
-                        abortf( "internal error, sigprocmask" );
-                } // if
-        } // if
 
         LIB_DEBUG_PRINT_SAFE("Kernel : core %p started\n", this);       
@@ -385 +347 @@
 }
 
-void BlockInternal() {
-        disable_interrupts();
-        verify( disable_preempt_count > 0 );
+void ScheduleInternal() {
         suspend();
-        verify( disable_preempt_count > 0 );
-        enable_interrupts( __PRETTY_FUNCTION__ );
-}
-
-void BlockInternal( spinlock * lock ) {
-        disable_interrupts();
+}
+
+void ScheduleInternal( spinlock * lock ) {
         this_processor->finish.action_code = Release;
         this_processor->finish.lock = lock;
-
-        verify( disable_preempt_count > 0 );
         suspend();
-        verify( disable_preempt_count > 0 );
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
-}
-
-void BlockInternal( thread_desc * thrd ) {
-        disable_interrupts();
+}
+
+void ScheduleInternal( thread_desc * thrd ) {
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
-
-        verify( disable_preempt_count > 0 );
         suspend();
-        verify( disable_preempt_count > 0 );
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
-}
-
-void BlockInternal( spinlock * lock, thread_desc * thrd ) {
-        disable_interrupts();
+}
+
+void ScheduleInternal( spinlock * lock, thread_desc * thrd ) {
         this_processor->finish.action_code = Release_Schedule;
         this_processor->finish.lock = lock;
         this_processor->finish.thrd = thrd;
-
-        verify( disable_preempt_count > 0 );
         suspend();
-        verify( disable_preempt_count > 0 );
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
-}
-
-void BlockInternal(spinlock ** locks, unsigned short count) {
-        disable_interrupts();
+}
+
+void ScheduleInternal(spinlock ** locks, unsigned short count) {
         this_processor->finish.action_code = Release_Multi;
         this_processor->finish.locks = locks;
         this_processor->finish.lock_count = count;
-
-        verify( disable_preempt_count > 0 );
         suspend();
-        verify( disable_preempt_count > 0 );
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
-}
-
-void BlockInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
-        disable_interrupts();
+}
+
+void ScheduleInternal(spinlock ** locks, unsigned short lock_count, thread_desc ** thrds, unsigned short thrd_count) {
         this_processor->finish.action_code = Release_Multi_Schedule;
         this_processor->finish.locks = locks;
@@ -450 +383 @@
         this_processor->finish.thrds = thrds;
         this_processor->finish.thrd_count = thrd_count;
-
-        verify( disable_preempt_count > 0 );
         suspend();
-        verify( disable_preempt_count > 0 );
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
 }
 
@@ -475 +403 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
+        // Enable preemption
+        kernel_start_preemption();
+
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
@@ -494 +425 @@
         this_processor->current_thread = mainThread;
         this_processor->current_coroutine = &mainThread->cor;
-        disable_preempt_count = 1;
-
-        // Enable preemption
-        kernel_start_preemption();
 
         // SKULLDUGGERY: Force a context switch to the system processor to set the main thread's context to the current UNIX
@@ -508 +435 @@
         // THE SYSTEM IS NOW COMPLETELY RUNNING
         LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
-
-        enable_interrupts( __PRETTY_FUNCTION__ );
 }
 
 void kernel_shutdown(void) {
         LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n");
-
-        disable_interrupts();
 
         // SKULLDUGGERY: Notify the systemProcessor it needs to terminates.
@@ -524 +447 @@
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
-
-        // Disable preemption
-        kernel_stop_preemption();
 
         // Destroy the system processor and its context in reverse order of construction
@@ -630 +550 @@
         if( !this->cond ) {
                 append( &this->blocked, this_thread() );
-                BlockInternal( &this->lock );
-        }
-        else {
-                unlock( &this->lock );
-        }
+                ScheduleInternal( &this->lock );
+                lock( &this->lock );
+        }
+        unlock( &this->lock );
 }
 
@@ -642 +561 @@
                 this->cond = true;
 
-                disable_interrupts();
                 thread_desc * it;
                 while( it = pop_head( &this->blocked) ) {
                         ScheduleThread( it );
                 }
-                enable_interrupts( __PRETTY_FUNCTION__ );
         }
         unlock( &this->lock );

src/libcfa/concurrency/kernel_private.h

@@ -30 +30 @@
 thread_desc * nextThread(cluster * this);
 
-void BlockInternal(void);
-void BlockInternal(spinlock * lock);
-void BlockInternal(thread_desc * thrd);
-void BlockInternal(spinlock * lock, thread_desc * thrd);
-void BlockInternal(spinlock ** locks, unsigned short count);
-void BlockInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count);
+void ScheduleInternal(void);
+void ScheduleInternal(spinlock * lock);
+void ScheduleInternal(thread_desc * thrd);
+void ScheduleInternal(spinlock * lock, thread_desc * thrd);
+void ScheduleInternal(spinlock ** locks, unsigned short count);
+void ScheduleInternal(spinlock ** locks, unsigned short count, thread_desc ** thrds, unsigned short thrd_count);
 
 //-----------------------------------------------------------------------------
@@ -60 +60 @@
 extern cluster * systemCluster;
 extern system_proc_t * systemProcessor;
-extern volatile thread_local processor * this_processor;
-extern volatile thread_local unsigned short disable_preempt_count;
+extern thread_local processor * this_processor;
 
-extern "C" {
-        void disable_interrupts();
-        void enable_interrupts_noRF();
-        void enable_interrupts( const char * );
+static inline void disable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST );
+        assert( prev != (unsigned short) -1 );
+}
+
+static inline void enable_interrupts_noRF() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        verify( prev != (unsigned short) 0 );
+}
+
+static inline void enable_interrupts() {
+        __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST );
+        verify( prev != (unsigned short) 0 );
+        if( prev == 1 && this_processor->pending_preemption ) {
+                ScheduleInternal( this_processor->current_thread );
+                this_processor->pending_preemption = false;
+        }
 }
 

src/libcfa/concurrency/monitor.c

@@ -63 +63 @@
                         append( &this->entry_queue, thrd );
                         LIB_DEBUG_PRINT_SAFE("%p Blocking on entry\n", thrd);
-                        BlockInternal( &this->lock );
-
-                        //BlockInternal will unlock spinlock, no need to unlock ourselves
+                        ScheduleInternal( &this->lock );
+
+                        //ScheduleInternal will unlock spinlock, no need to unlock ourselves
                         return; 
                 }
@@ -170 +170 @@
         unsigned short count = this->monitor_count;
         unsigned int recursions[ count ];               //Save the current recursion levels to restore them later
-        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to BlockInternal
+        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to ScheduleInternal
 
         LIB_DEBUG_PRINT_SAFE("count %i\n", count);
@@ -208 +208 @@
 
         // Everything is ready to go to sleep
-        BlockInternal( locks, count, threads, thread_count );
+        ScheduleInternal( locks, count, threads, thread_count );
 
 
@@ -281 +281 @@
         unsigned short count = this->monitor_count;
         unsigned int recursions[ count ];               //Save the current recursion levels to restore them later
-        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to BlockInternal
+        spinlock *   locks     [ count ];               //We need to pass-in an array of locks to ScheduleInternal
 
         lock_all( this->monitors, locks, count );
@@ -309 +309 @@
 
         //Everything is ready to go to sleep
-        BlockInternal( locks, count, &signallee, 1 );
+        ScheduleInternal( locks, count, &signallee, 1 );
 
 
@@ -339 +339 @@
         // unsigned short count = this->current_monitor_count;
         // unsigned int recursions[ count ];            //Save the current recursion levels to restore them later
-        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to BlockInternal
+        // spinlock *   locks     [ count ];            //We need to pass-in an array of locks to ScheduleInternal
 
         // lock_all( this->current_monitors, locks, count );
@@ -348 +348 @@
 
         // // // Everything is ready to go to sleep
-        // // BlockInternal( locks, count, threads, thread_count );
+        // // ScheduleInternal( locks, count, threads, thread_count );
 
 

src/libcfa/concurrency/preemption.c

@@ -17 +17 @@
 #include "preemption.h"
 
-
 extern "C" {
-#include <errno.h>
-#define __USE_GNU
 #include <signal.h>
-#undef __USE_GNU
-#include <stdio.h>
-#include <string.h>
-#include <unistd.h>
 }
 
-#include "libhdr.h"
-
-#define __CFA_DEFAULT_PREEMPTION__ 10000
+#define __CFA_DEFAULT_PREEMPTION__ 10
 
 __attribute__((weak)) unsigned int default_preemption() {
@@ -36 +27 @@
 }
 
-#define __CFA_SIGCXT__ ucontext_t *
-#define __CFA_SIGPARMS__ __attribute__((unused)) int sig, __attribute__((unused)) siginfo_t *sfp, __attribute__((unused)) __CFA_SIGCXT__ cxt
-
 static void preempt( processor   * this );
 static void timeout( thread_desc * this );
-
-void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
-void sigHandler_alarm    ( __CFA_SIGPARMS__ );
-
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags );
 
 //=============================================================================================
@@ -52 +35 @@
 
 void kernel_start_preemption() {
-        LIB_DEBUG_PRINT_SAFE("Kernel : Starting preemption\n");
-        __kernel_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO );
-        __kernel_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO );
+
 }
 
-void kernel_stop_preemption() {
-        //Block all signals, we are no longer in a position to handle them
-        sigset_t mask;
-        sigfillset( &mask );
-        sigprocmask( SIG_BLOCK, &mask, NULL );
-        LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n");
-
-        assert( !systemProcessor->alarms.head );
-        assert( systemProcessor->alarms.tail == &systemProcessor->alarms.head );
-}
-
-LIB_DEBUG_DO( bool validate( alarm_list_t * this ); )
-
 void tick_preemption() {
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Ticking preemption\n" );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
         alarm_list_t * alarms = &systemProcessor->alarms;
         __cfa_time_t currtime = __kernel_get_time();
         while( alarms->head && alarms->head->alarm < currtime ) {
                 alarm_node_t * node = pop(alarms);
-                LIB_DEBUG_DO(
-                        len = snprintf( text, 256, "Ticking %p\n", node );
-                        LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-                );
                 if( node->kernel_alarm ) {
                         preempt( node->proc );
@@ -92 +50 @@
                 }
 
-                LIB_DEBUG_DO( assert( validate( alarms ) ) );
-
                 if( node->period > 0 ) {
-                        node->alarm = currtime + node->period;
+                        node->alarm += node->period;
                         insert( alarms, node );
                 }
@@ -106 +62 @@
                 __kernel_set_timer( alarms->head->alarm - currtime );
         }
-
-        verify( validate( alarms ) );
-        LIB_DEBUG_DO(
-                len = snprintf( text, 256, "Ticking preemption done\n" );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
 }
 
 void update_preemption( processor * this, __cfa_time_t duration ) {
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Processor : %p updating preemption to %lu\n", this, duration );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
+        //     assert( THREAD_GETMEM( disableInt ) && THREAD_GETMEM( disableIntCnt ) == 1 );
         alarm_node_t * alarm = this->preemption_alarm;
-        duration *= 1000;
 
         // Alarms need to be enabled
@@ -153 +97 @@
 
 void ^?{}( preemption_scope * this ) {
-        disable_interrupts();
-
         update_preemption( this->proc, 0 );
 }
@@ -162 +104 @@
 //=============================================================================================
 
-extern "C" {
-        void disable_interrupts() {
-                __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST );
-                verify( new_val < (unsigned short)65_000 );
-                verify( new_val != (unsigned short) 0 );
-        }
-
-        void enable_interrupts_noRF() {
-                unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-                verify( prev != (unsigned short) 0 );
-        }
-
-        void enable_interrupts( const char * func ) {
-                unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST );
-                verify( prev != (unsigned short) 0 );
-                if( prev == 1 && this_processor->pending_preemption ) {
-                        this_processor->pending_preemption = false;
-                        LIB_DEBUG_DO(
-                                char text[256];
-                                __attribute__((unused)) int len = snprintf( text, 256, "Executing deferred CtxSwitch on %p\n", this_processor );
-                                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-                        );
-                        BlockInternal( this_processor->current_thread );
-                }
-
-                this_processor->last_enable = func;
-        }
-}
-
-static inline void signal_unblock( bool alarm ) {
-        sigset_t mask;
-        sigemptyset( &mask );
-        sigaddset( &mask, SIGUSR1 );
-
-        if( alarm ) sigaddset( &mask, SIGALRM );
-
-        if ( sigprocmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
-            abortf( "internal error, sigprocmask" );
-        } // if
-}
-
 static inline bool preemption_ready() {
-        return disable_preempt_count == 0;
+        return this_processor->disable_preempt_count == 0;
 }
 
@@ -215 +116 @@
 }
 
-void sigHandler_ctxSwitch( __CFA_SIGPARMS__ ) {
-
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Ctx Switch IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP]));
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
-        signal_unblock( false );
+void sigHandler_ctxSwitch( __attribute__((unused)) int sig ) {
         if( preemption_ready() ) {
-                LIB_DEBUG_DO(
-                        len = snprintf( text, 256, "Ctx Switch IRH : Blocking thread %p on %p\n", this_processor->current_thread, this_processor );
-                        LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-                );
-                BlockInternal( this_processor->current_thread );
+                ScheduleInternal( this_processor->current_thread );
         }
         else {
-                LIB_DEBUG_DO(
-                        len = snprintf( text, 256, "Ctx Switch IRH : Defering\n" );
-                        LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-                );
                 defer_ctxSwitch();
         }
 }
 
-void sigHandler_alarm( __CFA_SIGPARMS__ ) {
-
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "\nAlarm IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP]) );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
-        signal_unblock( true );
+void sigHandler_alarm( __attribute__((unused)) int sig ) {
         if( try_lock( &systemProcessor->alarm_lock ) ) {
                 tick_preemption();
@@ -256 +133 @@
                 defer_alarm();
         }
-
-        if( preemption_ready() && this_processor->pending_preemption ) {
-                LIB_DEBUG_DO(
-                        len = snprintf( text, 256, "Alarm IRH : Blocking thread\n" );
-                        LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-                );
-                this_processor->pending_preemption = false;
-                BlockInternal( this_processor->current_thread );
-        }
 }
 
 static void preempt( processor * this ) {
-        LIB_DEBUG_DO(
-                char text[256];
-                __attribute__((unused)) int len = snprintf( text, 256, "Processor : signalling %p\n", this );
-                LIB_DEBUG_WRITE( STDERR_FILENO, text, len );
-        );
-
-        if( this != systemProcessor ) {
-                pthread_kill( this->kernel_thread, SIGUSR1 );
-        }
-        else {
-                defer_ctxSwitch();
-        }
+        pthread_kill( this->kernel_thread, SIGUSR1 );
 }
 
@@ -285 +142 @@
         //TODO : implement waking threads
 }
-
-static void __kernel_sigaction( int sig, void (*handler)(__CFA_SIGPARMS__), int flags ) {
-        struct sigaction act;
-
-        act.sa_sigaction = (void (*)(int, siginfo_t *, void *))handler;
-        sigemptyset( &act.sa_mask );
-        sigaddset( &act.sa_mask, SIGALRM );             // disabled during signal handler
-        sigaddset( &act.sa_mask, SIGUSR1 );
-
-        act.sa_flags = flags;
-
-        if ( sigaction( sig, &act, NULL ) == -1 ) {
-                // THE KERNEL IS NOT STARTED SO CALL NO uC++ ROUTINES!
-                char helpText[256];
-                __attribute__((unused)) int len = snprintf( helpText, 256, " __kernel_sigaction( sig:%d, handler:%p, flags:%d ), problem installing signal handler, error(%d) %s.\n",
-                                sig, handler, flags, errno, strerror( errno ) );
-                LIB_DEBUG_WRITE( STDERR_FILENO, helpText, len );
-                _exit( EXIT_FAILURE );
-        } // if
-}

src/libcfa/concurrency/thread.c

@@ -28 +28 @@
 }
 
-extern volatile thread_local processor * this_processor;
+extern thread_local processor * this_processor;
 
 //-----------------------------------------------------------------------------
@@ -84 +84 @@
 
 void yield( void ) {
-        BlockInternal( this_processor->current_thread );
+        ScheduleInternal( this_processor->current_thread );
 }
 

src/libcfa/libhdr/libdebug.h

@@ -19 +19 @@
 #ifdef __CFA_DEBUG__
         #define LIB_DEBUG_DO(x) x
-        #define LIB_NO_DEBUG_DO(x)
+        #define LIB_NO_DEBUG_DO(x) ((void)0)
 #else
-        #define LIB_DEBUG_DO(x)
-        #define LIB_NO_DEBUG_DO(x) x
+        #define LIB_DEBUG_DO(x) ((void)0)
+        #define LIB_NO_DEBUG_DO(x) x      
 #endif