Changes in src/libcfa/concurrency/kernel.c [b69ea6b:c40e7c5]

File:

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

src/libcfa/concurrency/kernel.c

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Feb  8 23:52:19 2018
-// Update Count     : 5
+// Last Modified On : Tue Feb  6 21:51:26 2018
+// Update Count     : 4
 //
 
 //C Includes
 #include <stddef.h>
+#define ftype `ftype`
 extern "C" {
 #include <stdio.h>
@@ -23 +24 @@
 #include <unistd.h>
 }
+#undef ftype
 
 //CFA Includes
@@ -56 +58 @@
 thread_local processor *      volatile this_processor;
 
-// volatile thread_local bool preemption_in_progress = 0;
-// volatile thread_local bool preemption_enabled = false;
-// volatile thread_local unsigned short disable_preempt_count = 1;
-
-volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 };
+volatile thread_local bool preemption_in_progress = 0;
+volatile thread_local bool preemption_enabled = false;
+volatile thread_local unsigned short disable_preempt_count = 1;
 
 //-----------------------------------------------------------------------------
@@ -209 +209 @@
                         if(readyThread)
                         {
-                                verify( !preemption.enabled );
+                                verify( !preemption_enabled );
 
                                 runThread(this, readyThread);
 
-                                verify( !preemption.enabled );
+                                verify( !preemption_enabled );
 
                                 //Some actions need to be taken from the kernel
@@ -262 +262 @@
 void finishRunning(processor * this) with( this->finish ) {
         if( action_code == Release ) {
-                verify( !preemption.enabled );
+                verify( !preemption_enabled );
                 unlock( *lock );
         }
@@ -269 +269 @@
         }
         else if( action_code == Release_Schedule ) {
-                verify( !preemption.enabled );
+                verify( !preemption_enabled );
                 unlock( *lock );
                 ScheduleThread( thrd );
         }
         else if( action_code == Release_Multi ) {
-                verify( !preemption.enabled );
+                verify( !preemption_enabled );
                 for(int i = 0; i < lock_count; i++) {
                         unlock( *locks[i] );
@@ -306 +306 @@
         this_coroutine = NULL;
         this_thread = NULL;
-        preemption.enabled = false;
-        preemption.disable_count = 1;
+        preemption_enabled = false;
+        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
@@ -347 +347 @@
 }
 
-void kernel_first_resume(processor * this) {
-        coroutine_desc * src = this_coroutine;
-        coroutine_desc * dst = get_coroutine(*this->runner);
-
-        verify( !preemption.enabled );
-
-        create_stack(&dst->stack, dst->stack.size);
-        CtxStart(this->runner, CtxInvokeCoroutine);
-
-        verify( !preemption.enabled );
-
-        dst->last = src;
-        dst->starter = dst->starter ? dst->starter : src;
-
-        // set state of current coroutine to inactive
-        src->state = src->state == Halted ? Halted : Inactive;
-
-        // set new coroutine that task is executing
-        this_coroutine = dst;
-
-        // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch.
-        // Therefore, when first creating a coroutine, interrupts are enable before calling the main.
-        // This is consistent with thread creation. However, when creating the main processor coroutine,
-        // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will
-        // stay disabled.
-        disable_interrupts();
-
-        // context switch to specified coroutine
-        assert( src->stack.context );
-        CtxSwitch( src->stack.context, dst->stack.context );
-        // when CtxSwitch returns we are back in the src coroutine
-
-        // set state of new coroutine to active
-        src->state = Active;
-
-        verify( !preemption.enabled );
-}
-
 //-----------------------------------------------------------------------------
 // Scheduler routines
@@ -392 +354 @@
         verify( thrd->self_cor.state != Halted );
 
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
 
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
@@ -402 +364 @@
         }
 
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
 }
 
 thread_desc * nextThread(cluster * this) with( *this ) {
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
         lock( ready_queue_lock __cfaabi_dbg_ctx2 );
         thread_desc * head = pop_head( ready_queue );
         unlock( ready_queue_lock );
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
         return head;
 }
@@ -416 +378 @@
 void BlockInternal() {
         disable_interrupts();
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -427 +389 @@
         this_processor->finish.lock        = lock;
 
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -439 +401 @@
         this_processor->finish.thrd        = thrd;
 
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -453 +415 @@
         this_processor->finish.thrd        = thrd;
 
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -466 +428 @@
         this_processor->finish.lock_count  = count;
 
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -481 +443 @@
         this_processor->finish.thrd_count  = thrd_count;
 
-        verify( !preemption.enabled );
-        returnToKernel();
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
+        returnToKernel();
+        verify( !preemption_enabled );
 
         enable_interrupts( __cfaabi_dbg_ctx );
@@ -489 +451 @@
 
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
-        verify( !preemption.enabled );
+        verify( !preemption_enabled );
         this_processor->finish.action_code = thrd ? Release_Schedule : Release;
         this_processor->finish.lock        = lock;
@@ -503 +465 @@
 // Kernel boot procedures
 void kernel_startup(void) {
-        verify( !preemption.enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
 
@@ -541 +502 @@
         // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that
         // mainThread is on the ready queue when this call is made.
-        kernel_first_resume( this_processor );
+        resume( *mainProcessor->runner );
 
 
@@ -548 +509 @@
         __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n");
 
-        verify( !preemption.enabled );
         enable_interrupts( __cfaabi_dbg_ctx );
-        verify( preemption.enabled );
 }
 
@@ -556 +515 @@
         __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n");
 
-        verify( preemption.enabled );
         disable_interrupts();
-        verify( !preemption.enabled );
 
         // SKULLDUGGERY: Notify the mainProcessor it needs to terminates.