Changes in libcfa/src/concurrency/preemption.cfa [a3821fa:92bfda0]

File:

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

libcfa/src/concurrency/preemption.cfa

@@ -15 +15 @@
 
 #define __cforall_thread__
-// #define __CFA_DEBUG_PRINT_PREEMPTION__
 
 #include "preemption.hfa"
@@ -29 +28 @@
 #include "kernel_private.hfa"
 
-
 #if !defined(__CFA_DEFAULT_PREEMPTION__)
 #define __CFA_DEFAULT_PREEMPTION__ 10`ms
 #endif
 
-__attribute__((weak)) Duration default_preemption() {
-        const char * preempt_rate_s = getenv("CFA_DEFAULT_PREEMPTION");
-        if(!preempt_rate_s) {
-                __cfadbg_print_safe(preemption, "No CFA_DEFAULT_PREEMPTION in ENV\n");
-                return __CFA_DEFAULT_PREEMPTION__;
-        }
-
-        char * endptr = 0p;
-        long int preempt_rate_l = strtol(preempt_rate_s, &endptr, 10);
-        if(preempt_rate_l < 0 || preempt_rate_l > 65535) {
-                __cfadbg_print_safe(preemption, "CFA_DEFAULT_PREEMPTION out of range : %ld\n", preempt_rate_l);
-                return __CFA_DEFAULT_PREEMPTION__;
-        }
-        if('\0' != *endptr) {
-                __cfadbg_print_safe(preemption, "CFA_DEFAULT_PREEMPTION not a decimal number : %s\n", preempt_rate_s);
-                return __CFA_DEFAULT_PREEMPTION__;
-        }
-
-        return preempt_rate_l`ms;
+Duration default_preemption() __attribute__((weak)) {
+        return __CFA_DEFAULT_PREEMPTION__;
 }
 
@@ -117 +98 @@
         //Loop throught every thing expired
         while( node = get_expired( alarms, currtime ) ) {
-                __cfadbg_print_buffer_decl( preemption, " KERNEL: preemption tick %lu\n", currtime.tn);
+                // __cfaabi_dbg_print_buffer_decl( " KERNEL: preemption tick.\n" );
                 Duration period = node->period;
                 if( period == 0) {
@@ -123 +104 @@
                 }
 
-                __cfadbg_print_buffer_local( preemption, " KERNEL: alarm ticking node %p.\n", node );
-
-
                 // Check if this is a kernel
                 if( node->type == Kernel ) {
@@ -131 +109 @@
                 }
                 else if( node->type == User ) {
-                        __cfadbg_print_buffer_local( preemption, " KERNEL: alarm unparking %p.\n", node->thrd );
                         timeout( node->thrd );
                 }
@@ -140 +117 @@
                 // Check if this is a periodic alarm
                 if( period > 0 ) {
-                        __cfadbg_print_buffer_local( preemption, " KERNEL: alarm period is %lu.\n", period`ns );
+                        // __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
@@ -148 +125 @@
         // If there are still alarms pending, reset the timer
         if( & (*alarms)`first ) {
+                __cfadbg_print_buffer_decl(preemption, " 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( capped );
         }
@@ -315 +296 @@
         // Enable interrupts by decrementing the counter
         // If counter reaches 0, execute any pending __cfactx_switch
-        void enable_interrupts( bool poll ) {
+        void enable_interrupts( __cfaabi_dbg_ctx_param ) {
                 // Cache the processor now since interrupts can start happening after the atomic store
                 processor   * proc = __cfaabi_tls.this_processor;
-                /* paranoid */ verify( !poll || proc );
+                /* paranoid */ verify( proc );
 
                 with( __cfaabi_tls.preemption_state ){
@@ -340 +321 @@
                                 // Signal the compiler that a fence is needed but only for signal handlers
                                 __atomic_signal_fence(__ATOMIC_RELEASE);
-                                if( poll && proc->pending_preemption ) {
+                                if( proc->pending_preemption ) {
                                         proc->pending_preemption = false;
                                         force_yield( __POLL_PREEMPTION );
                                 }
                         }
+                }
+
+                // For debugging purposes : keep track of the last person to enable the interrupts
+                __cfaabi_dbg_debug_do( proc->last_enable = caller; )
+        }
+
+        // Disable interrupts by incrementint the counter
+        // Don't execute any pending __cfactx_switch even if counter reaches 0
+        void enable_interrupts_noPoll() {
+                unsigned short prev = __cfaabi_tls.preemption_state.disable_count;
+                __cfaabi_tls.preemption_state.disable_count -= 1;
+                // If this triggers someone is enabled already enabled interrupts
+                /* paranoid */ verifyf( prev != 0u, "Incremented from %u\n", prev );
+                if( prev == 1 ) {
+                        #if GCC_VERSION > 50000
+                                static_assert(__atomic_always_lock_free(sizeof(__cfaabi_tls.preemption_state.enabled), &__cfaabi_tls.preemption_state.enabled), "Must be lock-free");
+                        #endif
+                        // 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(&__cfaabi_tls.preemption_state.enabled, true, __ATOMIC_RELAXED);
+
+                        // Signal the compiler that a fence is needed but only for signal handlers
+                        __atomic_signal_fence(__ATOMIC_RELEASE);
                 }
         }
@@ -580 +585 @@
 
         // Setup proper signal handlers
-        __cfaabi_sigaction( SIGUSR1, sigHandler_ctxSwitch, SA_SIGINFO ); // __cfactx_switch handler
-        __cfaabi_sigaction( SIGALRM, sigHandler_alarm    , SA_SIGINFO ); // debug 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 );
@@ -684 +689 @@
 }
 
+#if !defined(__CFA_NO_STATISTICS__)
+        int __print_alarm_stats = 0;
+#endif
+
 // Main of the alarm thread
 // Waits on SIGALRM and send SIGUSR1 to whom ever needs it
 static void * alarm_loop( __attribute__((unused)) void * args ) {
         __processor_id_t id;
-        register_proc_id(&id);
+        id.full_proc = false;
+        id.id = doregister(&id);
         __cfaabi_tls.this_proc_id = &id;
 
+        #if !defined(__CFA_NO_STATISTICS__)
+                struct __stats_t local_stats;
+                __cfaabi_tls.this_stats = &local_stats;
+                __init_stats( &local_stats );
+        #endif
 
         // Block sigalrms to control when they arrive
@@ -749 +764 @@
 EXIT:
         __cfaabi_dbg_print_safe( "Kernel : Preemption thread stopping\n" );
-        register_proc_id(&id);
-
+        unregister(&id);
+
+        #if !defined(__CFA_NO_STATISTICS__)
+                if( 0 != __print_alarm_stats ) {
+                        __print_stats( &local_stats, __print_alarm_stats, "Alarm", "Thread", 0p );
+                }
+        #endif
         return 0p;
 }