Changeset 2a84d06d for src/libcfa/concurrency

Timestamp:

Mar 27, 2018, 5:22:58 PM (6 years ago)

Author:

Peter A. Buhr <pabuhr@…>

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:

43725bd

Parents:

af1ed1ad

Message:

second draft of time package and incorporation into runtime kernel

Location:

src/libcfa/concurrency

Files:

• alarm.c (modified) (5 diffs)
• alarm.h (modified) (5 diffs)
• kernel (modified) (3 diffs)
• preemption.c (modified) (8 diffs)
• preemption.h (modified) (2 diffs)

src/libcfa/concurrency/alarm.c

@@ -10 +10 @@
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:35:18 2017
-// Update Count     : 1
+// Last Modified On : Tue Mar 27 14:12:11 2018
+// Update Count     : 41
 //
 
@@ -27 +27 @@
 
 
-static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) {
-        it_value.tv_sec = alarm->val / (1`cfa_s).val;                   // seconds
-        it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds
-        it_interval.tv_sec = 0;
-        it_interval.tv_usec = 0;
-}
-
-static inline void ?{}( __cfa_time_t & this, timespec * curr ) {
-        uint64_t secs  = curr->tv_sec;
-        uint64_t nsecs = curr->tv_nsec;
-        this.val = from_s(secs).val + nsecs;
+static inline void ?{}( itimerval & this, Duration alarm ) with( this ) {
+        it_value   { alarm };                                                           // seconds, microseconds
+        it_interval{ 0 };
 }
 
@@ -44 +36 @@
 //=============================================================================================
 
-__cfa_time_t __kernel_get_time() {
+Time __kernel_get_time() {
         timespec curr;
-        clock_gettime( CLOCK_REALTIME, &curr );
-        return (__cfa_time_t){ &curr };
+        clock_gettime( CLOCK_MONOTONIC_RAW, &curr );            // CLOCK_REALTIME
+        return (Time){ curr };
 }
 
-void __kernel_set_timer( __cfa_time_t alarm ) {
-        itimerval val = { &alarm };
-        setitimer( ITIMER_REAL, &val, NULL );
+void __kernel_set_timer( Duration alarm ) {
+        setitimer( ITIMER_REAL, &(itimerval){ alarm }, NULL );
 }
 
@@ -59 +50 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
+void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period ) with( this ) {
         this.thrd = thrd;
         this.alarm = alarm;
@@ -68 +59 @@
 }
 
-void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) {
+void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period ) with( this ) {
         this.proc = proc;
         this.alarm = alarm;

src/libcfa/concurrency/alarm.h

@@ -10 +10 @@
 // Created On       : Fri Jun 2 11:31:25 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:59:27 2017
-// Update Count     : 3
+// Last Modified On : Mon Mar 26 16:25:41 2018
+// Update Count     : 11
 //
 
@@ -21 +21 @@
 #include <assert.h>
 
-#include "bits/cfatime.h"
+#include "time"
 
 struct thread_desc;
@@ -30 +30 @@
 //=============================================================================================
 
-__cfa_time_t __kernel_get_time();
-void __kernel_set_timer( __cfa_time_t alarm );
+Time __kernel_get_time();
+void __kernel_set_timer( Duration alarm );
 
 //=============================================================================================
@@ -38 +38 @@
 
 struct alarm_node_t {
-        __cfa_time_t alarm;             // time when alarm goes off
-        __cfa_time_t period;            // if > 0 => period of alarm
+        Time alarm;                             // time when alarm goes off
+        Duration period;                        // if > 0 => period of alarm
         alarm_node_t * next;            // intrusive link list field
 
@@ -53 +53 @@
 typedef alarm_node_t ** __alarm_it_t;
 
-void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
-void ?{}( alarm_node_t & this, processor   * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s );
+void ?{}( alarm_node_t & this, thread_desc * thrd, Time alarm, Duration period );
+void ?{}( alarm_node_t & this, processor   * proc, Time alarm, Duration period );
 void ^?{}( alarm_node_t & this );
 

src/libcfa/concurrency/kernel

@@ -10 +10 @@
 // Created On       : Tue Jan 17 12:27:26 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:58:39 2017
-// Update Count     : 2
+// Last Modified On : Fri Mar 23 17:08:20 2018
+// Update Count     : 3
 //
 
@@ -19 +19 @@
 
 #include "invoke.h"
-#include "bits/cfatime.h"
+#include "time"
 
 extern "C" {
@@ -49 +49 @@
 
         // Preemption rate on this cluster
-        __cfa_time_t preemption_rate;
+        Duration preemption_rate;
 };
 
-extern __cfa_time_t default_preemption();
+extern Duration default_preemption();
 
 void ?{} (cluster & this);

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 : Tue Mar 27 11:28:51 2018
+// Update Count     : 24
 //
 
@@ -27 +27 @@
 
 #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 +78 @@
 
 // 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 +88 @@
         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 +102 @@
 
                 // 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 +117 @@
 
 // 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;
@@ -291 +291 @@
 // 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 +301 @@
         disable_interrupts();
 
-        update_preemption( this.proc, 0`cfa_s );
+        update_preemption( this.proc, 0`s );
 }
 

src/libcfa/concurrency/preemption.h

@@ -10 +10 @@
 // Created On       : Mon Jun 5 14:20:42 2017
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 21 22:34:25 2017
-// Update Count     : 1
+// Last Modified On : Fri Mar 23 17:18:53 2018
+// Update Count     : 2
 //
 
@@ -21 +21 @@
 void kernel_start_preemption();
 void kernel_stop_preemption();
-void update_preemption( processor * this, __cfa_time_t duration );
+void update_preemption( processor * this, Duration duration );
 void tick_preemption();