Changeset 14a61b5 for src/libcfa/concurrency/preemption.c

Timestamp:

May 8, 2018, 11:55:33 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, with_gc

Children:

5fec3f6

Parents:

10cfad9

Message:

Ground work for quiescing processors and update/remove TL_GET/TL_SETs. Still work to be done in both cases

File:

• src/libcfa/concurrency/preemption.c (modified) (5 diffs)

src/libcfa/concurrency/preemption.c

@@ -234 +234 @@
 }
 
-
+// KERNEL ONLY
 // Check if a CtxSwitch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
-        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
+        // Check if preemption is safe
+        bool ready = kernelTLS.preemption_state.enabled && ! kernelTLS.preemption_state.in_progress;
+
+        // Adjust the pending flag accordingly
+        kernelTLS.this_processor->pending_preemption = !ready;
         return ready;
 }
@@ -254 +257 @@
 
         // Start with preemption disabled until ready
-        TL_GET( preemption_state ).enabled = false;
-        TL_GET( preemption_state ).disable_count = 1;
+        kernelTLS.preemption_state.enabled = false;
+        kernelTLS.preemption_state.disable_count = 1;
 
         // Initialize the event kernel
@@ -320 +323 @@
         // before the kernel thread has even started running. When that happens an iterrupt
         // we a null 'this_processor' will be caught, just ignore it.
-        if(!TL_GET( this_processor )) return;
+        if(! kernelTLS.this_processor ) return;
 
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
+                case PREEMPT_TERMINATE: verify( kernelTLS.this_processor->do_terminate);
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -332 +335 @@
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", TL_GET( this_processor ), TL_GET( this_thread ) );
-
-        TL_GET( preemption_state ).in_progress = true;  // Sync flag : prevent recursive calls to the signal handler
-        signal_unblock( SIGUSR1 );                          // We are about to CtxSwitch out of the signal handler, let other handlers in
-        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", kernelTLS.this_processor, kernelTLS.this_thread );
+
+        // Sync flag : prevent recursive calls to the signal handler
+        kernelTLS.preemption_state.in_progress = true;
+
+        // We are about to CtxSwitch out of the signal handler, let other handlers in
+        signal_unblock( SIGUSR1 );
+
+        // TODO: this should go in finish action
+        // Clear the in progress flag
+        kernelTLS.preemption_state.in_progress = false;
 
         // Preemption can occur here
 
-        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
+        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
 }
 
@@ -409 +418 @@
 
 void __cfaabi_check_preemption() {
-        bool ready = TL_GET( preemption_state ).enabled;
+        bool ready = kernelTLS.preemption_state.enabled;
         if(!ready) { abort("Preemption should be ready"); }