Changeset 9b1dcc2 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Jun 12, 2020, 1:49:17 PM (4 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, arm-eh, ast-experimental, enum, forall-pointer-decay, jacob/cs343-translation, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

cb196f2

Parents:

b388ee81

Message:

Changed scheduling API to adapt to non-Processors scheduling threads.

File:

• libcfa/src/concurrency/kernel.cfa (modified) (12 diffs)

libcfa/src/concurrency/kernel.cfa

@@ -300 +300 @@
         // register the processor unless it's the main thread which is handled in the boot sequence
         if(this != mainProcessor) {
-                this->id = doregister(this);
+                this->id = doregister((__processor_id_t*)this);
                 ready_queue_grow( this->cltr );
         }
@@ -346 +346 @@
         if(this != mainProcessor) {
                 ready_queue_shrink( this->cltr );
-                unregister(this);
+                unregister((__processor_id_t*)this);
         }
         else {
@@ -416 +416 @@
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
-                        __schedule_thread( thrd_dst );
+                        __schedule_thread( (__processor_id_t*)this, thrd_dst );
                         break RUNNING;
                 }
@@ -609 +609 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( $thread * thrd ) {
+void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
         /* paranoid */ verify( thrd );
         /* paranoid */ verify( thrd->state != Halted );
@@ -623 +623 @@
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
 
-        ready_schedule_lock( kernelTLS.this_processor );
+        ready_schedule_lock  ( id );
                 push( thrd->curr_cluster, thrd );
 
                 __wake_one(thrd->curr_cluster);
-        ready_schedule_unlock( kernelTLS.this_processor );
+        ready_schedule_unlock( id );
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -636 +636 @@
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
 
-        ready_schedule_lock( kernelTLS.this_processor );
+        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
                 $thread * head = pop( this );
-        ready_schedule_unlock( kernelTLS.this_processor );
+        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -645 +645 @@
 
 // KERNEL ONLY unpark with out disabling interrupts
-void __unpark( $thread * thrd __cfaabi_dbg_ctx_param2 ) {
+void __unpark(  struct __processor_id_t * id, $thread * thrd __cfaabi_dbg_ctx_param2 ) {
         static_assert(sizeof(thrd->state) == sizeof(int));
 
@@ -663 +663 @@
                         // Wake lost the race,
                         thrd->state = Blocked;
-                        __schedule_thread( thrd );
+                        __schedule_thread( id, thrd );
                         break;
                 case Rerun:
@@ -681 +681 @@
 
         disable_interrupts();
-        __unpark( thrd __cfaabi_dbg_ctx_fwd2 );
+        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd __cfaabi_dbg_ctx_fwd2 );
         enable_interrupts( __cfaabi_dbg_ctx );
 }
@@ -798 +798 @@
         (*mainProcessor){};
 
-        mainProcessor->id = doregister(mainProcessor);
+        mainProcessor->id = doregister( (__processor_id_t*)mainProcessor);
 
         //initialize the global state variables
@@ -809 +809 @@
         // Add the main thread to the ready queue
         // once resume is called on mainProcessor->runner the mainThread needs to be scheduled like any normal thread
-        __schedule_thread(mainThread);
+        __schedule_thread((__processor_id_t *)mainProcessor, mainThread);
 
         // SKULLDUGGERY: Force a context switch to the main processor to set the main thread's context to the current UNIX
@@ -853 +853 @@
         kernel_stop_preemption();
 
-        unregister(mainProcessor);
+        unregister((__processor_id_t*)mainProcessor);
 
         // Destroy the main processor and its context in reverse order of construction