Changes in src/libcfa/concurrency/kernel.c [0b33412:4aa2fb2]

File:

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

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 );