Changeset e873838 for libcfa/src/concurrency/kernel.cfa

Timestamp:

Nov 2, 2020, 12:44:43 PM (3 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

58688bf, 82f791f

Parents:

f7136f7

Message:

Removed unpark and added support for unpark from the kernel (removing the distinction between the two

File:

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

libcfa/src/concurrency/kernel.cfa

@@ -108 +108 @@
 static $thread * __next_thread_slow(cluster * this);
 static void __run_thread(processor * this, $thread * dst);
-static void __wake_one(struct __processor_id_t * id, cluster * cltr);
+static void __wake_one(cluster * cltr);
 
 static void push  (__cluster_idles & idles, processor & proc);
@@ -282 +282 @@
                 if(unlikely(thrd_dst->preempted != __NO_PREEMPTION)) {
                         // The thread was preempted, reschedule it and reset the flag
-                        __schedule_thread( (__processor_id_t*)this, thrd_dst );
+                        __schedule_thread( thrd_dst );
                         break RUNNING;
                 }
@@ -358 +358 @@
 // Scheduler routines
 // KERNEL ONLY
-void __schedule_thread( struct __processor_id_t * id, $thread * thrd ) {
+void __schedule_thread( $thread * thrd ) {
         /* paranoid */ verify( thrd );
         /* paranoid */ verify( thrd->state != Halted );
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         /* paranoid */ #if defined( __CFA_WITH_VERIFY__ )
         /* paranoid */  if( thrd->state == Blocked || thrd->state == Start ) assertf( thrd->preempted == __NO_PREEMPTION,
@@ -374 +375 @@
         if (thrd->preempted == __NO_PREEMPTION) thrd->state = Ready;
 
-        ready_schedule_lock  ( id );
+        ready_schedule_lock();
                 push( thrd->curr_cluster, thrd );
-                __wake_one(id, thrd->curr_cluster);
-        ready_schedule_unlock( id );
+                __wake_one(thrd->curr_cluster);
+        ready_schedule_unlock();
 
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
@@ -384 +385 @@
 // KERNEL ONLY
 static inline $thread * __next_thread(cluster * this) with( *this ) {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+        ready_schedule_lock();
                 $thread * thrd = pop( this );
-        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_unlock();
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         return thrd;
 }
@@ -396 +399 @@
 // KERNEL ONLY
 static inline $thread * __next_thread_slow(cluster * this) with( *this ) {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-
-        ready_schedule_lock  ( (__processor_id_t*)kernelTLS.this_processor );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+        ready_schedule_lock();
                 $thread * thrd = pop_slow( this );
-        ready_schedule_unlock( (__processor_id_t*)kernelTLS.this_processor );
-
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        ready_schedule_unlock();
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
         return thrd;
 }
 
-// KERNEL ONLY unpark with out disabling interrupts
-void __unpark(  struct __processor_id_t * id, $thread * thrd ) {
+void unpark( $thread * thrd ) {
+        if( !thrd ) return;
+
+        /* paranoid */ verify( kernelTLS.this_proc_id );
+        bool full = kernelTLS.this_proc_id->full_proc;
+        if(full) disable_interrupts();
+
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
         int old_ticket = __atomic_fetch_add(&thrd->ticket, 1, __ATOMIC_SEQ_CST);
         switch(old_ticket) {
@@ -418 +429 @@
 
                         // Wake lost the race,
-                        __schedule_thread( id, thrd );
+                        __schedule_thread( thrd );
                         break;
                 default:
@@ -424 +435 @@
                         abort("Thread %p (%s) has mismatch park/unpark\n", thrd, thrd->self_cor.name);
         }
-}
-
-void unpark( $thread * thrd ) {
-        if( !thrd ) return;
-
-        disable_interrupts();
-        __unpark( (__processor_id_t*)kernelTLS.this_processor, thrd );
-        enable_interrupts( __cfaabi_dbg_ctx );
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+
+        if(full) enable_interrupts( __cfaabi_dbg_ctx );
+        /* paranoid */ verify( kernelTLS.this_proc_id );
 }
 
@@ -505 +512 @@
 //=============================================================================================
 // Wake a thread from the front if there are any
-static void __wake_one(struct __processor_id_t * id, cluster * this) {
-        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
-        /* paranoid */ verify( ready_schedule_islocked( id ) );
+static void __wake_one(cluster * this) {
+        /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );
+        /* paranoid */ verify( ready_schedule_islocked() );
 
         // Check if there is a sleeping processor
@@ -525 +532 @@
         #endif
 
-        /* paranoid */ verify( ready_schedule_islocked( id ) );
+        /* paranoid */ verify( ready_schedule_islocked() );
         /* paranoid */ verify( ! kernelTLS.preemption_state.enabled );