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

File:

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

src/libcfa/concurrency/preemption.c

@@ -23 +23 @@
 }
 
+#include "bits/cfatime.h"
 #include "bits/signal.h"
 
-//TODO move to defaults
-#define __CFA_DEFAULT_PREEMPTION__ 10000
-
-//TODO move to defaults
-__attribute__((weak)) unsigned int default_preemption() {
+#if !defined(__CFA_DEFAULT_PREEMPTION__)
+#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
+#endif
+
+__cfa_time_t default_preemption() __attribute__((weak)) {
         return __CFA_DEFAULT_PREEMPTION__;
 }
@@ -149 +150 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                preemption.enabled = false;
-                __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1;
-                preemption.disable_count = new_val;
+                preemption_state.enabled = false;
+                __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
+                preemption_state.disable_count = new_val;
                 verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
         }
@@ -161 +162 @@
                 thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
 
-                unsigned short prev = preemption.disable_count;
-                preemption.disable_count -= 1;
+                unsigned short prev = preemption_state.disable_count;
+                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 ) {
-                        preemption.enabled = true;
+                        preemption_state.enabled = true;
                         if( proc->pending_preemption ) {
                                 proc->pending_preemption = false;
@@ -181 +182 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = preemption.disable_count;
-                preemption.disable_count -= 1;
+                unsigned short prev = preemption_state.disable_count;
+                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 ) {
-                        preemption.enabled = true;
+                        preemption_state.enabled = true;
                 }
         }
@@ -235 +236 @@
 // 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_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
         this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
         return ready;
@@ -250 +251 @@
 
         // Start with preemption disabled until ready
-        preemption.enabled = false;
-        preemption.disable_count = 1;
+        preemption_state.enabled = false;
+        preemption_state.disable_count = 1;
 
         // Initialize the event kernel
@@ -294 +295 @@
         this.proc->preemption_alarm = &this.alarm;
 
-        update_preemption( this.proc, from_us(this.proc->cltr->preemption) );
+        update_preemption( this.proc, this.proc->cltr->preemption_rate );
 }
 
@@ -330 +331 @@
         __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
+        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
-        preemption.in_progress = false;                     // Clear the in progress flag
+        preemption_state.in_progress = false;                     // Clear the in progress flag
 
         // Preemption can occur here