Changeset b826e6b for src/libcfa/concurrency/alarm.c

Timestamp:

Jul 19, 2017, 11:49:33 AM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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:

9cc0472

Parents:

fea3faa (diff), a57cb58 (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/alarm.c (modified) (10 diffs)

src/libcfa/concurrency/alarm.c

@@ -16 +16 @@
 
 extern "C" {
+#include <errno.h>
+#include <stdio.h>
+#include <string.h>
 #include <time.h>
+#include <unistd.h>
 #include <sys/time.h>
 }
+
+#include "libhdr.h"
 
 #include "alarm.h"
@@ -25 +31 @@
 
 //=============================================================================================
+// time type
+//=============================================================================================
+
+#define one_second         1_000_000_000ul
+#define one_milisecond         1_000_000ul
+#define one_microsecond            1_000ul
+#define one_nanosecond                 1ul
+
+__cfa_time_t zero_time = { 0 };
+
+void ?{}( __cfa_time_t * this ) { this->val = 0; }
+void ?{}( __cfa_time_t * this, zero_t zero ) { this->val = 0; }
+
+void ?{}( itimerval * this, __cfa_time_t * alarm ) {
+        this->it_value.tv_sec = alarm->val / one_second;                        // seconds
+        this->it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds
+        this->it_interval.tv_sec = 0;
+        this->it_interval.tv_usec = 0;
+}
+
+
+void ?{}( __cfa_time_t * this, timespec * curr ) {
+        uint64_t secs  = curr->tv_sec;
+        uint64_t nsecs = curr->tv_nsec;
+        this->val = (secs * one_second) + nsecs;
+}
+
+__cfa_time_t ?=?( __cfa_time_t * this, zero_t rhs ) {
+        this->val = 0;
+        return *this;
+}
+
+__cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; }
+__cfa_time_t from_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val *     1_000_000ul; return ret; }
+__cfa_time_t from_us( uint64_t val ) { __cfa_time_t ret; ret.val = val *         1_000ul; return ret; }
+__cfa_time_t from_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val *             1ul; return ret; }
+
+//=============================================================================================
 // Clock logic
 //=============================================================================================
@@ -31 +75 @@
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
-        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
+        return (__cfa_time_t){ &curr };
 }
 
 void __kernel_set_timer( __cfa_time_t alarm ) {
-        itimerval val;
-        val.it_value.tv_sec = alarm / TIMEGRAN;                 // seconds
-        val.it_value.tv_usec = (alarm % TIMEGRAN) / ( TIMEGRAN / 1_000_000L ); // microseconds
-        val.it_interval.tv_sec = 0;
-        val.it_interval.tv_usec = 0;
+        itimerval val = { &alarm };
         setitimer( ITIMER_REAL, &val, NULL );
 }
@@ -47 +87 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->thrd = thrd;
         this->alarm = alarm;
@@ -56 +96 @@
 }
 
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
         this->proc = proc;
         this->alarm = alarm;
@@ -71 +111 @@
 }
 
+LIB_DEBUG_DO( bool validate( alarm_list_t * this ) {
+        alarm_node_t ** it = &this->head;
+        while( (*it) ) {
+                it = &(*it)->next;
+        }
+
+        return it == this->tail;
+})
+
 static inline void insert_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t p ) {
-        assert( !n->next );
+        verify( !n->next );
         if( p == this->tail ) {
                 this->tail = &n->next;
@@ -80 +129 @@
         }
         *p = n;
+
+        verify( validate( this ) );
 }
 
@@ -89 +140 @@
 
         insert_at( this, n, it );
+
+        verify( validate( this ) );
 }
 
@@ -100 +153 @@
                 head->next = NULL;
         }
+        verify( validate( this ) );
         return head;
 }
@@ -105 +159 @@
 static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
         verify( it );
-        verify( (*it)->next == n );
-
-        (*it)->next = n->next;
+        verify( (*it) == n );
+
+        (*it) = n->next;
         if( !n-> next ) {
                 this->tail = it;
         }
         n->next = NULL;
+
+        verify( validate( this ) );
 }
 
 static inline void remove( alarm_list_t * this, alarm_node_t * n ) {
         alarm_node_t ** it = &this->head;
-        while( (*it) && (*it)->next != n ) {
+        while( (*it) && (*it) != n ) {
                 it = &(*it)->next;
         }
 
+        verify( validate( this ) );
+
         if( *it ) { remove_at( this, n, it ); }
+
+        verify( validate( this ) );
 }
 
 void register_self( alarm_node_t * this ) {
+        alarm_list_t * alarms = &event_kernel->alarms;
+
         disable_interrupts();
-        assert( !systemProcessor->pending_alarm );
-        lock( &systemProcessor->alarm_lock );
+        lock( &event_kernel->lock DEBUG_CTX2 );
         {
-                insert( &systemProcessor->alarms, this );
-                if( systemProcessor->pending_alarm ) {
-                        tick_preemption();
+                verify( validate( alarms ) );
+                bool first = !alarms->head;
+
+                insert( alarms, this );
+                if( first ) {
+                        __kernel_set_timer( alarms->head->alarm - __kernel_get_time() );
                 }
         }
-        unlock( &systemProcessor->alarm_lock );
+        unlock( &event_kernel->lock );
         this->set = true;
-        enable_interrupts();
+        enable_interrupts( DEBUG_CTX );
 }
 
 void unregister_self( alarm_node_t * this ) {
         disable_interrupts();
-        lock( &systemProcessor->alarm_lock );
-        remove( &systemProcessor->alarms, this );
-        unlock( &systemProcessor->alarm_lock );
-        disable_interrupts();
+        lock( &event_kernel->lock DEBUG_CTX2 );
+        {
+                verify( validate( &event_kernel->alarms ) );
+                remove( &event_kernel->alarms, this );
+        }
+        unlock( &event_kernel->lock );
+        enable_interrupts( DEBUG_CTX );
         this->set = false;
 }