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

Timestamp:

May 25, 2018, 2:51:06 PM (6 years ago)

Author:

Aaron Moss <a3moss@…>

Branches:

new-env, with_gc

Children:

cdc4d43

Parents:

3ef35bd (diff), 58e822a (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) (11 diffs)

src/libcfa/concurrency/preemption.c

@@ -15 +15 @@
 
 #include "preemption.h"
+#include <assert.h>
 
 extern "C" {
@@ -91 +92 @@
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
+                // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
 
                 // Check if this is a kernel
@@ -103 +105 @@
                 Duration period = node->period;
                 if( period > 0 ) {
+                        // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
@@ -112 +115 @@
 
         // If there are still alarms pending, reset the timer
-        if( alarms->head ) { __kernel_set_timer( alarms->head->alarm - currtime ); }
+        if( alarms->head ) {
+                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%lu(%lu) resetting alarm to %lu.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                Duration delta = alarms->head->alarm - currtime;
+                Duration caped = max(delta, 50`us);
+                // itimerval tim  = { caped };
+                // __cfaabi_dbg_print_buffer_local( "    Values are %lu, %lu, %lu %lu.\n", delta.tv, caped.tv, tim.it_value.tv_sec, tim.it_value.tv_usec);
+
+                __kernel_set_timer( caped );
+        }
 }
 
@@ -150 +161 @@
         void disable_interrupts() {
                 with( kernelTLS.preemption_state ) {
-                        enabled = false;
+                        static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+
+                        // Set enabled flag to false
+                        // should be atomic to avoid preemption in the middle of the operation.
+                        // use memory order RELAXED since there is no inter-thread on this variable requirements
+                        __atomic_store_n(&enabled, false, __ATOMIC_RELAXED);
+
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_ACQUIRE);
+
                         __attribute__((unused)) unsigned short new_val = disable_count + 1;
                         disable_count = new_val;
@@ -160 +180 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                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
+                processor   * proc = kernelTLS.this_processor; // Cache the processor now since interrupts can start happening after the atomic store
+                thread_desc * thrd = kernelTLS.this_thread;       // Cache the thread now since interrupts can start happening after the atomic store
 
                 with( kernelTLS.preemption_state ){
@@ -170 +190 @@
                         // Check if we need to prempt the thread because an interrupt was missed
                         if( prev == 1 ) {
-                                enabled = true;
+                                static_assert(__atomic_always_lock_free(sizeof(enabled), &enabled), "Must be lock-free");
+
+                                // Set enabled flag to true
+                                // should be atomic to avoid preemption in the middle of the operation.
+                                // use memory order RELAXED since there is no inter-thread on this variable requirements
+                                __atomic_store_n(&enabled, true, __ATOMIC_RELAXED);
+
+                                // Signal the compiler that a fence is needed but only for signal handlers
+                                __atomic_signal_fence(__ATOMIC_RELEASE);
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
@@ -189 +217 @@
                 verifyf( prev != 0u, "Incremented from %u\n", prev );                     // If this triggers someone is enabled already enabled interrupts
                 if( prev == 1 ) {
-                        kernelTLS.preemption_state.enabled = true;
+                        static_assert(__atomic_always_lock_free(sizeof(kernelTLS.preemption_state.enabled), &kernelTLS.preemption_state.enabled), "Must be lock-free");
+                        // Set enabled flag to true
+                        // should be atomic to avoid preemption in the middle of the operation.
+                        // use memory order RELAXED since there is no inter-thread on this variable requirements
+                        __atomic_store_n(&kernelTLS.preemption_state.enabled, true, __ATOMIC_RELAXED);
+
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_RELEASE);
                 }
         }
@@ -335 +370 @@
         if( !preemption_ready() ) { return; }
 
-        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", kernelTLS.this_processor, kernelTLS.this_thread );
+        __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p @ %p).\n", kernelTLS.this_processor, kernelTLS.this_thread, (void *)(cxt->uc_mcontext.CFA_REG_IP) );
 
         // 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 );
+        // Clear sighandler mask before context switching.
+        static_assert( sizeof( sigset_t ) == sizeof( cxt->uc_sigmask ), "Expected cxt->uc_sigmask to be of sigset_t" );
+        if ( pthread_sigmask( SIG_SETMASK, (sigset_t *)&(cxt->uc_sigmask), NULL ) == -1 ) {
+                abort( "internal error, sigprocmask" );
+        }
 
         // TODO: this should go in finish action
@@ -377 +415 @@
                                 case EAGAIN :
                                 case EINTR :
+                                        {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );}
                                         continue;
                         case EINVAL :
@@ -424 +463 @@
         sigset_t oldset;
         int ret;
-        ret = sigprocmask(0, NULL, &oldset);
+        ret = pthread_sigmask(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"); }
+
+        ret = sigismember(&oldset, SIGALRM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 0) { abort("ERROR SIGALRM is enabled"); }
+
+        ret = sigismember(&oldset, SIGTERM);
+        if(ret <  0) { abort("ERROR sigismember returned %d", ret); }
+        if(ret == 1) { abort("ERROR SIGTERM is disabled"); }
 }