Changes in src/libcfa/concurrency/preemption.c [381fdee:b69ea6b]

File:

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

src/libcfa/concurrency/preemption.c

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  9 14:42:34 2018
-// Update Count     : 25
+// Last Modified On : Fri Feb  9 16:38:13 2018
+// Update Count     : 14
 //
 
@@ -67 +67 @@
 }
 
+enum {
+        PREEMPT_NORMAL    = 0,
+        PREEMPT_TERMINATE = 1,
+};
+
 //=============================================================================================
 // Kernel Preemption logic
@@ -144 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                preemption_enabled = false;
-                __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1;
-                disable_preempt_count = new_val;
+                preemption.enabled = false;
+                __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
+                preemption.disable_count = new_val;
                 verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
         }
@@ -156 +161 @@
                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
-                unsigned short prev = disable_preempt_count;
-                disable_preempt_count -= 1;
+                unsigned short prev = preemption.disable_count;
+                preemption.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 ) {
-                        preemption_enabled = true;
+                        preemption.enabled = true;
                         if( proc->pending_preemption ) {
                                 proc->pending_preemption = false;
@@ -176 +181 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = disable_preempt_count;
-                disable_preempt_count -= 1;
+                unsigned short prev = preemption.disable_count;
+                preemption.disable_count -= 1;
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        preemption_enabled = true;
+                        preemption.enabled = true;
                 }
         }
@@ -192 +197 @@
 
         if ( pthread_sigmask( SIG_UNBLOCK, &mask, NULL ) == -1 ) {
-            abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
         }
 }
@@ -203 +208 @@
 
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
-            abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
         }
 }
@@ -209 +214 @@
 // kill wrapper : signal a processor
 static void preempt( processor * this ) {
-        pthread_kill( this->kernel_thread, SIGUSR1 );
+        sigval_t value = { PREEMPT_NORMAL };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
+}
+
+// kill wrapper : signal a processor
+void terminate(processor * this) {
+        this->do_terminate = true;
+        sigval_t value = { PREEMPT_TERMINATE };
+        pthread_sigqueue( this->kernel_thread, SIGUSR1, value );
 }
 
@@ -222 +235 @@
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-        bool ready = preemption_enabled && !preemption_in_progress; // Check if preemption is safe
+        bool ready = preemption.enabled && !preemption.in_progress; // Check if preemption is safe
         this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
         return ready;
@@ -234 +247 @@
 // Called from kernel_startup
 void kernel_start_preemption() {
-        __cfaabi_dbg_print_safe("Kernel : Starting preemption\n");
+        __cfaabi_dbg_print_safe( "Kernel : Starting preemption\n" );
 
         // Start with preemption disabled until ready
-        preemption_enabled = false;
-        disable_preempt_count = 1;
+        preemption.enabled = false;
+        preemption.disable_count = 1;
 
         // Initialize the event kernel
@@ -255 +268 @@
 // Called from kernel_shutdown
 void kernel_stop_preemption() {
-        __cfaabi_dbg_print_safe("Kernel : Preemption stopping\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption stopping\n" );
 
         // Block all signals since we are already shutting down
@@ -271 +284 @@
         // Preemption is now fully stopped
 
-        __cfaabi_dbg_print_safe("Kernel : Preemption stopped\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption stopped\n" );
 }
 
@@ -277 +290 @@
 // Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope & this, processor * proc ) {
-        (this.alarm){ proc, zero_time, zero_time };
+        (this.alarm){ proc, 0`cfa_s, 0`cfa_s };
         this.proc = proc;
         this.proc->preemption_alarm = &this.alarm;
@@ -287 +300 @@
         disable_interrupts();
 
-        update_preemption( this.proc, zero_time );
+        update_preemption( this.proc, 0`cfa_s );
 }
 
@@ -299 +312 @@
         __cfaabi_dbg_debug_do( last_interrupt = (void *)(cxt->uc_mcontext.CFA_REG_IP); )
 
+        // SKULLDUGGERY: if a thread creates a processor and the immediately deletes it,
+        // the interrupt that is supposed to force the kernel thread to preempt might arrive
+        // 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(!this_processor) return;
+
+        choose(sfp->si_value.sival_int) {
+                case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
+                case PREEMPT_TERMINATE: verify(this_processor->do_terminate);
+                default:
+                        abort( "internal error, signal value is %d", sfp->si_value.sival_int );
+        }
+
         // Check if it is safe to preempt here
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl(" KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
-
-        preemption_in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
+
+        preemption.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
-        preemption_in_progress = false;                     // Clear the in progress flag
+        preemption.in_progress = false;                     // Clear the in progress flag
 
         // Preemption can occur here
@@ -322 +348 @@
 
         if ( pthread_sigmask( SIG_BLOCK, &mask, NULL ) == -1 ) {
-            abortf( "internal error, pthread_sigmask" );
+            abort( "internal error, pthread_sigmask" );
         }
 
@@ -339 +365 @@
                                         continue;
                         case EINVAL :
-                                        abortf("Timeout was invalid.");
+                                        abort( "Timeout was invalid." );
                                 default:
-                                        abortf("Unhandled error %d", err);
+                                        abort( "Unhandled error %d", err);
                         }
                 }
@@ -348 +374 @@
                 assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int);
 
-                // __cfaabi_dbg_print_safe("Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
+                // __cfaabi_dbg_print_safe( "Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int );
                 // Switch on the code (a.k.a. the sender) to
                 switch( info.si_code )
@@ -356 +382 @@
                 case SI_TIMER:
                 case SI_KERNEL:
-                        // __cfaabi_dbg_print_safe("Kernel : Preemption thread tick\n");
+                        // __cfaabi_dbg_print_safe( "Kernel : Preemption thread tick\n" );
                         lock( event_kernel->lock __cfaabi_dbg_ctx2 );
                         tick_preemption();
@@ -370 +396 @@
 
 EXIT:
-        __cfaabi_dbg_print_safe("Kernel : Preemption thread stopping\n");
+        __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
         return NULL;
 }