Changeset 32cab5b for src/libcfa/concurrency/preemption.c

Timestamp:

Apr 17, 2018, 12:01:09 PM (7 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, with_gc

Children:

3265399

Parents:

b2fe1c9 (diff), 81bb114 (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 branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

File:

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

src/libcfa/concurrency/preemption.c

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Feb  9 16:38:13 2018
-// Update Count     : 14
+// Last Modified On : Mon Apr  9 13:52:39 2018
+// Update Count     : 36
 //
 
@@ -23 +23 @@
 }
 
-#include "bits/cfatime.h"
 #include "bits/signal.h"
 
 #if !defined(__CFA_DEFAULT_PREEMPTION__)
-#define __CFA_DEFAULT_PREEMPTION__ 10`cfa_ms
+#define __CFA_DEFAULT_PREEMPTION__ 10`ms
 #endif
 
-__cfa_time_t default_preemption() __attribute__((weak)) {
+Duration default_preemption() __attribute__((weak)) {
         return __CFA_DEFAULT_PREEMPTION__;
 }
@@ -78 +77 @@
 
 // Get next expired node
-static inline alarm_node_t * get_expired( alarm_list_t * alarms, __cfa_time_t currtime ) {
+static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) {
         if( !alarms->head ) return NULL;                          // If no alarms return null
         if( alarms->head->alarm >= currtime ) return NULL;        // If alarms head not expired return null
@@ -88 +87 @@
         alarm_node_t * node = NULL;                     // Used in the while loop but cannot be declared in the while condition
         alarm_list_t * alarms = &event_kernel->alarms;  // Local copy for ease of reading
-        __cfa_time_t currtime = __kernel_get_time();    // Check current time once so we everything "happens at once"
+        Time currtime = __kernel_get_time();                    // Check current time once so we everything "happens at once"
 
         //Loop throught every thing expired
@@ -102 +101 @@
 
                 // Check if this is a periodic alarm
-                __cfa_time_t period = node->period;
+                Duration period = node->period;
                 if( period > 0 ) {
                         node->alarm = currtime + period;    // Alarm is periodic, add currtime to it (used cached current time)
@@ -117 +116 @@
 
 // Update the preemption of a processor and notify interested parties
-void update_preemption( processor * this, __cfa_time_t duration ) {
+void update_preemption( processor * this, Duration duration ) {
         alarm_node_t * alarm = this->preemption_alarm;
 
         // Alarms need to be enabled
-        if ( duration > 0 && !alarm->set ) {
+        if ( duration > 0 && ! alarm->set ) {
                 alarm->alarm = __kernel_get_time() + duration;
                 alarm->period = duration;
                 register_self( alarm );
         }
-        // Zero duraction but alarm is set
+        // Zero duration but alarm is set
         else if ( duration == 0 && alarm->set ) {
                 unregister_self( alarm );
@@ -150 +149 @@
         // Disable interrupts by incrementing the counter
         void disable_interrupts() {
-                preemption_state.enabled = false;
-                __attribute__((unused)) unsigned short new_val = preemption_state.disable_count + 1;
-                preemption_state.disable_count = new_val;
+                TL_GET( preemption_state ).enabled = false;
+                __attribute__((unused)) unsigned short new_val = TL_GET( preemption_state ).disable_count + 1;
+                TL_GET( preemption_state ).disable_count = new_val;
                 verify( new_val < 65_000u );              // If this triggers someone is disabling interrupts without enabling them
         }
@@ -159 +158 @@
         // If counter reaches 0, execute any pending CtxSwitch
         void enable_interrupts( __cfaabi_dbg_ctx_param ) {
-                processor   * proc = this_processor;      // Cache the processor now since interrupts can start happening after the atomic add
-                thread_desc * thrd = this_thread;         // Cache the thread now since interrupts can start happening after the atomic add
-
-                unsigned short prev = preemption_state.disable_count;
-                preemption_state.disable_count -= 1;
+                processor   * proc = TL_GET( this_processor ); // Cache the processor now since interrupts can start happening after the atomic add
+                thread_desc * thrd = TL_GET( this_thread );       // Cache the thread now since interrupts can start happening after the atomic add
+
+                unsigned short prev = TL_GET( preemption_state ).disable_count;
+                TL_GET( 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_state.enabled = true;
+                        TL_GET( preemption_state ).enabled = true;
                         if( proc->pending_preemption ) {
                                 proc->pending_preemption = false;
@@ -182 +181 @@
         // Don't execute any pending CtxSwitch even if counter reaches 0
         void enable_interrupts_noPoll() {
-                unsigned short prev = preemption_state.disable_count;
-                preemption_state.disable_count -= 1;
+                unsigned short prev = TL_GET( preemption_state ).disable_count;
+                TL_GET( 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_state.enabled = true;
+                        TL_GET( preemption_state ).enabled = true;
                 }
         }
@@ -236 +235 @@
 // If false : preemption is unsafe and marked as pending
 static inline bool preemption_ready() {
-        bool ready = preemption_state.enabled && !preemption_state.in_progress; // Check if preemption is safe
-        this_processor->pending_preemption = !ready;                        // Adjust the pending flag accordingly
+        bool ready = TL_GET( preemption_state ).enabled && !TL_GET( preemption_state ).in_progress; // Check if preemption is safe
+        TL_GET( this_processor )->pending_preemption = !ready;                  // Adjust the pending flag accordingly
         return ready;
 }
@@ -251 +250 @@
 
         // Start with preemption disabled until ready
-        preemption_state.enabled = false;
-        preemption_state.disable_count = 1;
+        TL_GET( preemption_state ).enabled = false;
+        TL_GET( preemption_state ).disable_count = 1;
 
         // Initialize the event kernel
@@ -291 +290 @@
 // Used by thread to control when they want to receive preemption signals
 void ?{}( preemption_scope & this, processor * proc ) {
-        (this.alarm){ proc, 0`cfa_s, 0`cfa_s };
+        (this.alarm){ proc, (Time){ 0 }, 0`s };
         this.proc = proc;
         this.proc->preemption_alarm = &this.alarm;
@@ -301 +300 @@
         disable_interrupts();
 
-        update_preemption( this.proc, 0`cfa_s );
+        update_preemption( this.proc, 0`s );
 }
 
@@ -317 +316 @@
         // before the kernel thread has even started running. When that happens an iterrupt
         // we a null 'this_processor' will be caught, just ignore it.
-        if(!this_processor) return;
+        if(!TL_GET( this_processor )) return;
 
         choose(sfp->si_value.sival_int) {
                 case PREEMPT_NORMAL   : ;// Normal case, nothing to do here
-                case PREEMPT_TERMINATE: verify(this_processor->do_terminate);
+                case PREEMPT_TERMINATE: verify(TL_GET( this_processor )->do_terminate);
                 default:
                         abort( "internal error, signal value is %d", sfp->si_value.sival_int );
@@ -331 +330 @@
         __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread);
 
-        preemption_state.in_progress = true;                      // Sync flag : prevent recursive calls to the signal handler
+        TL_GET( 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_state.in_progress = false;                     // Clear the in progress flag
+        TL_GET( preemption_state ).in_progress = false; // Clear the in progress flag
 
         // Preemption can occur here
 
-        BlockInternal( (thread_desc*)this_thread );         // Do the actual CtxSwitch
+        BlockInternal( (thread_desc*)TL_GET( this_thread ) ); // Do the actual CtxSwitch
 }