Changes in src/libcfa/concurrency/alarm.c [969b3fe:4aa2fb2]

File:

• src/libcfa/concurrency/alarm.c (modified) (9 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"
 #include "kernel_private.h"
 #include "preemption.h"
-
-//=============================================================================================
-// 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; }
 
 //=============================================================================================
@@ -75 +31 @@
         timespec curr;
         clock_gettime( CLOCK_REALTIME, &curr );
-        return (__cfa_time_t){ &curr };
+        return ((__cfa_time_t)curr.tv_sec * TIMEGRAN) + curr.tv_nsec;
 }
 
 void __kernel_set_timer( __cfa_time_t alarm ) {
-        itimerval val = { &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;
         setitimer( ITIMER_REAL, &val, NULL );
 }
@@ -87 +47 @@
 //=============================================================================================
 
-void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, thread_desc * thrd, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->thrd = thrd;
         this->alarm = alarm;
@@ -96 +56 @@
 }
 
-void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) {
+void ?{}( alarm_node_t * this, processor   * proc, __cfa_time_t alarm = 0, __cfa_time_t period = 0 ) {
         this->proc = proc;
         this->alarm = alarm;
@@ -111 +71 @@
 }
 
-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 ) {
-        verify( !n->next );
+        assert( !n->next );
         if( p == this->tail ) {
                 this->tail = &n->next;
@@ -129 +80 @@
         }
         *p = n;
-
-        verify( validate( this ) );
 }
 
@@ -140 +89 @@
 
         insert_at( this, n, it );
-
-        verify( validate( this ) );
 }
 
@@ -153 +100 @@
                 head->next = NULL;
         }
-        verify( validate( this ) );
         return head;
 }
@@ -159 +105 @@
 static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) {
         verify( it );
-        verify( (*it) == n );
+        verify( (*it)->next == n );
 
-        (*it) = n->next;
+        (*it)->next = 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) != n ) {
+        while( (*it) && (*it)->next != 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();
-        lock( &event_kernel->lock DEBUG_CTX2 );
+        assert( !systemProcessor->pending_alarm );
+        lock( &systemProcessor->alarm_lock );
         {
-                verify( validate( alarms ) );
-                bool first = !alarms->head;
-
-                insert( alarms, this );
-                if( first ) {
-                        __kernel_set_timer( alarms->head->alarm - __kernel_get_time() );
+                insert( &systemProcessor->alarms, this );
+                if( systemProcessor->pending_alarm ) {
+                        tick_preemption();
                 }
         }
-        unlock( &event_kernel->lock );
+        unlock( &systemProcessor->alarm_lock );
         this->set = true;
-        enable_interrupts( DEBUG_CTX );
+        enable_interrupts();
 }
 
 void unregister_self( alarm_node_t * this ) {
         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 );
+        lock( &systemProcessor->alarm_lock );
+        remove( &systemProcessor->alarms, this );
+        unlock( &systemProcessor->alarm_lock );
+        disable_interrupts();
         this->set = false;
 }