Changes in libcfa/src/concurrency/preemption.cfa [c84b4be:d3ab183]

File:

• libcfa/src/concurrency/preemption.cfa (modified) (12 diffs)

libcfa/src/concurrency/preemption.cfa

@@ -39 +39 @@
 // FwdDeclarations : timeout handlers
 static void preempt( processor   * this );
-static void timeout( thread_desc * this );
+static void timeout( $thread * this );
 
 // FwdDeclarations : Signal handlers
 static void sigHandler_ctxSwitch( __CFA_SIGPARMS__ );
+static void sigHandler_alarm    ( __CFA_SIGPARMS__ );
 static void sigHandler_segv     ( __CFA_SIGPARMS__ );
 static void sigHandler_ill      ( __CFA_SIGPARMS__ );
@@ -83 +84 @@
 // Get next expired node
 static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
-        if( !alarms->head ) return 0p;                                          // If no alarms return null
-        if( alarms->head->alarm >= currtime ) return 0p;        // If alarms head not expired return null
+        if( ! & (*alarms)`first ) return 0p;                                            // If no alarms return null
+        if( (*alarms)`first.alarm >= currtime ) return 0p;      // If alarms head not expired return null
         return pop(alarms);                                                                     // Otherwise just pop head
 }
@@ -97 +98 @@
         while( node = get_expired( alarms, currtime ) ) {
                 // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
+                Duration period = node->period;
+                if( period == 0) {
+                        node->set = false;                  // Node is one-shot, just mark it as not pending
+                }
 
                 // Check if this is a kernel
@@ -107 +112 @@
 
                 // Check if this is a periodic alarm
-                Duration period = node->period;
                 if( period > 0 ) {
                         // __cfaabi_dbg_print_buffer_local( " KERNEL: alarm period is %lu.\n", period.tv );
@@ -113 +117 @@
                         insert( alarms, node );             // Reinsert the node for the next time it triggers
                 }
-                else {
-                        node->set = false;                  // Node is one-shot, just mark it as not pending
-                }
         }
 
         // If there are still alarms pending, reset the timer
-        if( alarms->head ) {
-                // __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
-                Duration delta = alarms->head->alarm - currtime;
-                Duration caped = max(delta, 50`us);
+        if( & (*alarms)`first ) {
+                __cfaabi_dbg_print_buffer_decl( " KERNEL: @%ju(%ju) resetting alarm to %ju.\n", currtime.tv, __kernel_get_time().tv, (alarms->head->alarm - currtime).tv);
+                Duration delta = (*alarms)`first.alarm - currtime;
+                Duration capped = 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 );
+                __kernel_set_timer( capped );
         }
 }
@@ -184 +185 @@
 
         // Enable interrupts by decrementing the counter
-        // If counter reaches 0, execute any pending CtxSwitch
+        // If counter reaches 0, execute any pending __cfactx_switch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 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 ){
@@ -209 +209 @@
                                 if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
-                                        BlockInternal( thrd );
+                                        force_yield( __POLL_PREEMPTION );
                                 }
                         }
@@ -219 +219 @@
 
         // Disable interrupts by incrementint the counter
-        // Don't execute any pending CtxSwitch even if counter reaches 0
+        // Don't execute any pending __cfactx_switch even if counter reaches 0
         void enable_interrupts_noPoll() {
                 unsigned short prev = kernelTLS.preemption_state.disable_count;
@@ -257 +257 @@
 
         if ( pthread_sigmask( SIG_BLOCK, &mask, 0p ) == -1 ) {
-            abort( "internal error, pthread_sigmask" );
+                abort( "internal error, pthread_sigmask" );
         }
 }
@@ -268 +268 @@
 
 // reserved for future use
-static void timeout( thread_desc * this ) {
-        //TODO : implement waking threads
+static void timeout( $thread * this ) {
+        __unpark( this __cfaabi_dbg_ctx2 );
 }
 
 // KERNEL ONLY
-// Check if a CtxSwitch signal handler shoud defer
+// Check if a __cfactx_switch signal handler shoud defer
 // If true  : preemption is safe
 // If false : preemption is unsafe and marked as pending
@@ -303 +303 @@
 
         // Setup proper signal handlers
-        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // CtxSwitch handler
+        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO | SA_RESTART ); // __cfactx_switch handler
+        __cfaabi_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO | SA_RESTART ); // debug handler
 
         signal_block( SIGALRM );
 
-        alarm_stack = create_pthread( &alarm_thread, alarm_loop, 0p );
+        alarm_stack = __create_pthread( &alarm_thread, alarm_loop, 0p );
 }
 
@@ -394 +395 @@
         // Preemption can occur here
 
-        BlockInternal( kernelTLS.this_thread ); // Do the actual CtxSwitch
+        force_yield( __ALARM_PREEMPTION ); // Do the actual __cfactx_switch
+}
+
+static void sigHandler_alarm( __CFA_SIGPARMS__ ) {
+        abort("SIGALRM should never reach the signal handler");
 }