Changes in src/libcfa/concurrency/kernel.c [01963df:de6319f]

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 : Fri Mar 30 18:26:11 2018
-// Update Count     : 23
+// Last Modified On : Mon Apr  9 16:11:46 2018
+// Update Count     : 24
 //
 
@@ -25 +25 @@
 
 //CFA Includes
+#include "time"
 #include "kernel_private.h"
 #include "preemption.h"
@@ -41 +42 @@
 KERNEL_STORAGE(cluster,           mainCluster);
 KERNEL_STORAGE(processor,         mainProcessor);
-KERNEL_STORAGE(processorCtx_t,    mainProcessorCtx);
 KERNEL_STORAGE(thread_desc,       mainThread);
 KERNEL_STORAGE(machine_context_t, mainThreadCtx);
 
-cluster *     mainCluster;
-processor *   mainProcessor;
+cluster     * mainCluster;
+processor   * mainProcessor;
 thread_desc * mainThread;
 
@@ -64 +64 @@
 
 //-----------------------------------------------------------------------------
-// Main thread construction
+// Struct to steal stack
 struct current_stack_info_t {
         machine_context_t ctx;
@@ -89 +89 @@
 }
 
+//-----------------------------------------------------------------------------
+// Main thread construction
 void ?{}( coStack_t & this, current_stack_info_t * info) with( this ) {
         size      = info->size;
@@ -110 +112 @@
         self_cor{ info };
         curr_cor = &self_cor;
+        curr_cluster = mainCluster;
         self_mon.owner = &this;
         self_mon.recursion = 1;
@@ -125 +128 @@
 //-----------------------------------------------------------------------------
 // Processor coroutine
-void ?{}(processorCtx_t & this) {}
-
-// Construct the processor context of the main processor
-void ?{}(processorCtx_t & this, processor * proc) {
-        (this.__cor){ "Processor" };
-        this.__cor.starter = NULL;
-        this.proc = proc;
+void ?{}(processorCtx_t & this) {
+
 }
 
@@ -140 +138 @@
 }
 
-void ?{}(processor & this) {
-        this{ mainCluster };
-}
-
-void ?{}(processor & this, cluster * cltr) with( this ) {
-        this.cltr = cltr;
+void ?{}(processor & this, const char * name, cluster & cltr) with( this ) {
+        this.name = name;
+        this.cltr = &cltr;
         terminated{ 0 };
         do_terminate = false;
@@ -153 +148 @@
 
         start( &this );
-}
-
-void ?{}(processor & this, cluster * cltr, processorCtx_t & runner) with( this ) {
-        this.cltr = cltr;
-        terminated{ 0 };
-        do_terminate = false;
-        preemption_alarm = NULL;
-        pending_preemption = false;
-        kernel_thread = pthread_self();
-        runner.proc = &this;
-
-        __cfaabi_dbg_print_safe("Kernel : constructing main processor context %p\n", &runner);
-        runner{ &this };
 }
 
@@ -180 +162 @@
 }
 
-void ?{}(cluster & this) with( this ) {
+void ?{}(cluster & this, const char * name, Duration preemption_rate) with( this ) {
+        this.name = name;
+        this.preemption_rate = preemption_rate;
         ready_queue{};
         ready_queue_lock{};
-
-        preemption_rate = default_preemption();
 }
 
@@ -311 +293 @@
         TL_SET( this_coroutine, NULL );
         TL_SET( this_thread, NULL );
-        TL_GET( preemption_state ).enabled = false;
-        TL_GET( preemption_state ).disable_count = 1;
+        TL_GET( preemption_state ).[enabled, disable_count] = [false, 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
@@ -401 +382 @@
         verifyf( thrd->next == NULL, "Expected null got %p", thrd->next );
 
-        with( *TL_GET( this_processor )->cltr ) {
+        with( *thrd->curr_cluster ) {
                 lock  ( ready_queue_lock __cfaabi_dbg_ctx2 );
                 append( ready_queue, thrd );
@@ -429 +410 @@
 void BlockInternal( __spinlock_t * lock ) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release;
-        TL_GET( this_processor )->finish.lock        = lock;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = Release;
+                finish.lock        = lock;
+        }
 
         verify( ! TL_GET( preemption_state ).enabled );
@@ -441 +424 @@
 void BlockInternal( thread_desc * thrd ) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Schedule;
-        TL_GET( this_processor )->finish.thrd        = thrd;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = Schedule;
+                finish.thrd        = thrd;
+        }
 
         verify( ! TL_GET( preemption_state ).enabled );
@@ -454 +439 @@
         assert(thrd);
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Schedule;
-        TL_GET( this_processor )->finish.lock        = lock;
-        TL_GET( this_processor )->finish.thrd        = thrd;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = Release_Schedule;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
 
         verify( ! TL_GET( preemption_state ).enabled );
@@ -467 +454 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short count) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Multi;
-        TL_GET( this_processor )->finish.locks       = locks;
-        TL_GET( this_processor )->finish.lock_count  = count;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = Release_Multi;
+                finish.locks       = locks;
+                finish.lock_count  = count;
+        }
 
         verify( ! TL_GET( preemption_state ).enabled );
@@ -480 +469 @@
 void BlockInternal(__spinlock_t * locks [], unsigned short lock_count, thread_desc * thrds [], unsigned short thrd_count) {
         disable_interrupts();
-        TL_GET( this_processor )->finish.action_code = Release_Multi_Schedule;
-        TL_GET( this_processor )->finish.locks       = locks;
-        TL_GET( this_processor )->finish.lock_count  = lock_count;
-        TL_GET( this_processor )->finish.thrds       = thrds;
-        TL_GET( this_processor )->finish.thrd_count  = thrd_count;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = Release_Multi_Schedule;
+                finish.locks       = locks;
+                finish.lock_count  = lock_count;
+                finish.thrds       = thrds;
+                finish.thrd_count  = thrd_count;
+        }
 
         verify( ! TL_GET( preemption_state ).enabled );
@@ -495 +486 @@
 void LeaveThread(__spinlock_t * lock, thread_desc * thrd) {
         verify( ! TL_GET( preemption_state ).enabled );
-        TL_GET( this_processor )->finish.action_code = thrd ? Release_Schedule : Release;
-        TL_GET( this_processor )->finish.lock        = lock;
-        TL_GET( this_processor )->finish.thrd        = thrd;
+        with( *TL_GET( this_processor ) ) {
+                finish.action_code = thrd ? Release_Schedule : Release;
+                finish.lock        = lock;
+                finish.thrd        = thrd;
+        }
 
         returnToKernel();
@@ -510 +503 @@
         verify( ! TL_GET( preemption_state ).enabled );
         __cfaabi_dbg_print_safe("Kernel : Starting\n");
+
+        // Initialize the main cluster
+        mainCluster = (cluster *)&storage_mainCluster;
+        (*mainCluster){"Main Cluster"};
+
+        __cfaabi_dbg_print_safe("Kernel : Main cluster ready\n");
 
         // Start by initializing the main thread
@@ -520 +519 @@
         __cfaabi_dbg_print_safe("Kernel : Main thread ready\n");
 
-        // Initialize the main cluster
-        mainCluster = (cluster *)&storage_mainCluster;
-        (*mainCluster){};
-
-        __cfaabi_dbg_print_safe("Kernel : main cluster ready\n");
+
+
+        // Construct the processor context of the main processor
+        void ?{}(processorCtx_t & this, processor * proc) {
+                (this.__cor){ "Processor" };
+                this.__cor.starter = NULL;
+                this.proc = proc;
+        }
+
+        void ?{}(processor & this) with( this ) {
+                name = "Main Processor";
+                cltr = mainCluster;
+                terminated{ 0 };
+                do_terminate = false;
+                preemption_alarm = NULL;
+                pending_preemption = false;
+                kernel_thread = pthread_self();
+
+                runner{ &this };
+                __cfaabi_dbg_print_safe("Kernel : constructed main processor context %p\n", &runner);
+        }
 
         // Initialize the main processor and the main processor ctx
         // (the coroutine that contains the processing control flow)
         mainProcessor = (processor *)&storage_mainProcessor;
-        (*mainProcessor){ mainCluster, *(processorCtx_t *)&storage_mainProcessorCtx };
+        (*mainProcessor){};
 
         //initialize the global state variables
@@ -724 +739 @@
                 thrd->dbg_next = NULL;
         }
+
+        void __cfaabi_dbg_record(__spinlock_t & this, const char * prev_name) {
+                this.prev_name = prev_name;
+                this.prev_thrd = TL_GET( this_thread );
+        }
 )
 // Local Variables: //