Changes in src/libcfa/concurrency/kernel.c [82ff5845:c81ebf9]

File:

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

src/libcfa/concurrency/kernel.c

@@ -154 +154 @@
         (&this->terminated){};
         this->is_terminated = false;
-        this->preemption_alarm = NULL;
-        this->preemption = default_preemption();
-        this->disable_preempt_count = 1;
+        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 };
 }
@@ -243 +240 @@
         //Update global state
         this->current_thread = dst;
-
-        LIB_DEBUG_PRINT_SAFE("Kernel : running %p\n", dst);
 
         // Context Switch to the thread
@@ -327 +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);       
@@ -379 +347 @@
 }
 
-void BlockInternal() {
-        disable_interrupts();
+void ScheduleInternal() {
         suspend();
-        enable_interrupts();
-}
-
-void BlockInternal( spinlock * lock ) {
-        disable_interrupts();
+}
+
+void ScheduleInternal( spinlock * lock ) {
         this_processor->finish.action_code = Release;
         this_processor->finish.lock = lock;
         suspend();
-        enable_interrupts();
-}
-
-void BlockInternal( thread_desc * thrd ) {
-        disable_interrupts();
+}
+
+void ScheduleInternal( thread_desc * thrd ) {
         this_processor->finish.action_code = Schedule;
         this_processor->finish.thrd = thrd;
         suspend();
-        enable_interrupts();
-}
-
-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;
         suspend();
-        enable_interrupts();
-}
-
-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;
         suspend();
-        enable_interrupts();
-}
-
-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;
@@ -427 +384 @@
         this_processor->finish.thrd_count = thrd_count;
         suspend();
-        enable_interrupts();
 }
 
@@ -447 +403 @@
         LIB_DEBUG_PRINT_SAFE("Kernel : Main thread ready\n");
 
+        // Enable preemption
+        kernel_start_preemption();
+
         // Initialize the system cluster
         systemCluster = (cluster *)&systemCluster_storage;
@@ -467 +426 @@
         this_processor->current_coroutine = &mainThread->cor;
 
-        // 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
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
@@ -479 +435 @@
         // THE SYSTEM IS NOW COMPLETELY RUNNING
         LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n");
-
-        enable_interrupts();
 }
 
@@ -493 +447 @@
 
         // THE SYSTEM IS NOW COMPLETELY STOPPED
-
-        // Disable preemption
-        kernel_stop_preemption();
 
         // Destroy the system processor and its context in reverse order of construction
@@ -599 +550 @@
         if( !this->cond ) {
                 append( &this->blocked, this_thread() );
-                BlockInternal( &this->lock );
+                ScheduleInternal( &this->lock );
                 lock( &this->lock );
         }