Changeset ff29f08 for src/libcfa/concurrency/preemption.c

Timestamp:

May 18, 2018, 2:09:21 PM (7 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

2472a19

Parents:

f6f0cca3 (diff), c7d8100c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge remote-tracking branch 'origin/master' into with_gc

File:

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

src/libcfa/concurrency/preemption.c

@@ -149 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                TL_GET( preemption_state ).enabled = false;
-                __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1;
-                TL_GET( preemption_state ).disable_count = new_val;
-                verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
+                with( kernelTLS.preemption_state ) {
+                        enabled = false;
+                        __attribute__((unused)) unsigned short new_val = disable_count + 1;
+                        disable_count = new_val;
+                        verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
+                }
         }
 
@@ -158 +160 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
-                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
-
-                unsigned short prev = TL_GET( preemption_state ).disable_count;
-                TL_GET( preemption_state ).disable_count -= 1;
-                verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
-
-                // Check if we need to prempt the thread because an interrupt was missed
-                if( prev == 1 ) {
-                        TL_GET( preemption_state ).enabled = true;
-                        if( proc->pending_preemption ) {
-                                proc->pending_preemption = false;
-                                BlockInternal( thrd );
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic add
+
+                with( kernelTLS.preemption_state ){
+                        unsigned short prev = disable_count;
+                        disable_count -= 1;
+                        verify( prev != 0u );                     // If this triggers someone is enabled already enabled interruptsverify( prev != 0u );
+
+                        // Check if we need to prempt the thread because an interrupt was missed
+                        if( prev == 1 ) {
+                                enabled = true;
+                                if( proc->pending_preemption ) {
+                                        proc->pending_preemption = false;
+                                        BlockInternal( thrd );
+                                }
                         }
                 }
@@ -181 +185 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = TL_GET( preemption_state ).disable_count;
-                TL_GET( preemption_state ).disable_count -= 1;
+                unsigned short prev = kernelTLS.preemption_state.disable_count;
+                kernelTLS.preemption_state.disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        TL_GET( preemption_state ).enabled = true;
+                        kernelTLS.preemption_state.enabled = true;
                 }
         }
@@ -230 +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;
 }
@@ -250 +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
@@ -316 +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 );
@@ -328 +335 @@
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, 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
 }
 
@@ -344 +357 @@
         // Block sigalrms to control when they arrive
         sigset_t mask;
+        sigfillset(&mask);
+        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
+            abort( "internal error, pthread_sigmask" );
+        }
+
         sigemptyset( &mask );
         sigaddset( &mask, SIGALRM );
-
-        if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
-            abort( "internal error, pthread_sigmask" );
-        }
 
         // Main loop
@@ -400 +414 @@
 }
 
+//=============================================================================================
+// Kernel Signal Debug
+//=============================================================================================
+
+void __cfaabi_check_preemption() {
+        bool ready = kernelTLS.preemption_state.enabled;
+        if(!ready) { abort("Preemption should be ready"); }
+
+        sigset_t oldset;
+        int ret;
+        ret = sigprocmask(0, NULL, &oldset);
+        if(ret != 0) { abort("ERROR sigprocmask returned %d", ret); }
+
+        ret = sigismember(&oldset, SIGUSR1);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+
+        if(ret == 1) { abort("ERROR SIGUSR1 is disabled"); }
+}
+
 // Local Variables: //
 // mode: c //