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

Timestamp:

Feb 15, 2018, 10:52:35 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

d27e340

Parents:

ff2d1139

Message:

Updated alarm to use bits/cfatime and fixed preemption for coroutines

File:

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

src/libcfa/concurrency/preemption.c

@@ -149 +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
         }
@@ -161 +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;
@@ -181 +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;
                 }
         }
@@ -235 +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;
@@ -250 +250 @@
 
         // Start with preemption disabled until ready
-        preemption_enabled = false;
-        disable_preempt_count = 1;
+        preemption.enabled = false;
+        preemption.disable_count = 1;
 
         // Initialize the event kernel
@@ -290 +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;
@@ -300 +300 @@
         disable_interrupts();
 
-        update_preemption( this.proc, zero_time );
+        update_preemption( this.proc, 0`cfa_s );
 }
 
@@ -330 +330 @@
         __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.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