Index: libcfa/src/concurrency/alarm.cfa =================================================================== --- libcfa/src/concurrency/alarm.cfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/alarm.cfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -38,6 +38,11 @@ void __kernel_set_timer( Duration alarm ) { - verifyf(alarm >= 1`us || alarm == 0, "Setting timer to < 1us (%jins)", alarm`ns); - setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p ); + alarm = max(alarm, 1`us); + itimerval otv @= { 0 }; + getitimer( ITIMER_REAL, &otv ); + Duration od = { otv.it_value }; + if(od == 0 || od > alarm) { + setitimer( ITIMER_REAL, &(itimerval){ alarm }, 0p ); + } } @@ -46,22 +51,22 @@ //============================================================================================= -void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period) with( this ) { +void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period) with( this ) { + this.initial = alarm; + this.period = period; this.thrd = thrd; - this.alarm = alarm; - this.period = period; set = false; type = User; } -void ?{}( alarm_node_t & this, processor * proc, Time alarm, Duration period ) with( this ) { +void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period ) with( this ) { + this.initial = alarm; + this.period = period; this.proc = proc; - this.alarm = alarm; - this.period = period; set = false; type = Kernel; } -void ?{}( alarm_node_t & this, Alarm_Callback callback, Time alarm, Duration period ) with( this ) { - this.alarm = alarm; - this.period = period; +void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period ) with( this ) { + this.initial = alarm; + this.period = period; this.callback = callback; set = false; @@ -77,5 +82,5 @@ void insert( alarm_list_t * this, alarm_node_t * n ) { alarm_node_t * it = & (*this)`first; - while( it && (n->alarm > it->alarm) ) { + while( it && (n->timeval > it->timeval) ) { it = & (*it)`next; } @@ -105,12 +110,12 @@ lock( event_kernel->lock __cfaabi_dbg_ctx2 ); { - verify( validate( alarms ) ); - bool first = ! & alarms`first; + Time curr = __kernel_get_time(); + this->timeval = curr + this->initial; - __cfadbg_print_safe( preemption, " KERNEL: alarm inserting %p (%lu).\n", this, this->alarm.tn ); + /* paranoid */ verify( validate( alarms ) ); + + __cfadbg_print_safe( preemption, " KERNEL: alarm inserting %p (%lu -> %lu).\n", this, curr.tn, this->timeval.tn ); insert( &alarms, this ); - if( first ) { - __kernel_set_timer( alarms`first.alarm - __kernel_get_time() ); - } + __kernel_set_timer( this->initial ); } unlock( event_kernel->lock ); @@ -136,5 +141,5 @@ void sleep( Duration duration ) { - alarm_node_t node = { active_thread(), __kernel_get_time() + duration, 0`s }; + alarm_node_t node = { active_thread(), duration, 0`s }; register_self( &node ); Index: libcfa/src/concurrency/alarm.hfa =================================================================== --- libcfa/src/concurrency/alarm.hfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/alarm.hfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -46,23 +46,24 @@ struct alarm_node_t { - Time alarm; // time when alarm goes off - Duration period; // if > 0 => period of alarm + Duration initial; // time when alarm goes off + Duration period; // if > 0 => period of alarm inline dlink(alarm_node_t); union { - $thread * thrd; // thrd who created event - processor * proc; // proc who created event - Alarm_Callback callback; // callback to handle event + $thread * thrd; // thrd who created event + processor * proc; // proc who created event + Alarm_Callback callback; // callback to handle event }; - bool set :1; // whether or not the alarm has be registered - enum alarm_type type; // true if this is not a user defined alarm + Time timeval; // actual time at which the alarm goes off + enum alarm_type type; // true if this is not a user defined alarm + bool set :1; // whether or not the alarm has be registered }; P9_EMBEDDED( alarm_node_t, dlink(alarm_node_t) ) -void ?{}( alarm_node_t & this, $thread * thrd, Time alarm, Duration period ); -void ?{}( alarm_node_t & this, processor * proc, Time alarm, Duration period ); -void ?{}( alarm_node_t & this, Alarm_Callback callback, Time alarm, Duration period ); +void ?{}( alarm_node_t & this, $thread * thrd, Duration alarm, Duration period ); +void ?{}( alarm_node_t & this, processor * proc, Duration alarm, Duration period ); +void ?{}( alarm_node_t & this, Alarm_Callback callback, Duration alarm, Duration period ); void ^?{}( alarm_node_t & this ); Index: libcfa/src/concurrency/clib/cfathread.cfa =================================================================== --- libcfa/src/concurrency/clib/cfathread.cfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/clib/cfathread.cfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -27,4 +27,6 @@ extern void __cfactx_invoke_thread(void (*main)(void *), void * this); } + +extern Time __kernel_get_time(); //================================================================================ @@ -265,5 +267,8 @@ int cfathread_cond_timedwait(cfathread_cond_t *restrict cond, cfathread_mutex_t *restrict mut, const struct timespec *restrict abstime) __attribute__((nonnull (1,2,3))) { Time t = { *abstime }; - if( wait( (*cond)->impl, (*mut)->impl, t ) ) { + timespec curr; + clock_gettime( CLOCK_REALTIME, &curr ); + Time c = { curr }; + if( wait( (*cond)->impl, (*mut)->impl, t - c ) ) { return 0; } Index: libcfa/src/concurrency/clib/cfathread.h =================================================================== --- libcfa/src/concurrency/clib/cfathread.h (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/clib/cfathread.h (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -80,4 +80,6 @@ typedef struct cfathread_cond_attr { + // WARNING: adding support for pthread_condattr_setclock would require keeping track of the clock + // and reading it in cond_timedwait } cfathread_condattr_t; typedef struct cfathread_condition * cfathread_cond_t; Index: libcfa/src/concurrency/locks.cfa =================================================================== --- libcfa/src/concurrency/locks.cfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/locks.cfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -191,5 +191,5 @@ }; - void ?{}( alarm_node_wrap(L) & this, Time alarm, Duration period, Alarm_Callback callback, condition_variable(L) * c, info_thread(L) * i ) { + void ?{}( alarm_node_wrap(L) & this, Duration alarm, Duration period, Alarm_Callback callback, condition_variable(L) * c, info_thread(L) * i ) { this.alarm_node{ callback, alarm, period }; this.cond = c; @@ -313,5 +313,5 @@ // helper for wait()'s' with a timeout - void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Time t ) with(this) { + void queue_info_thread_timeout( condition_variable(L) & this, info_thread(L) & info, Duration t ) with(this) { lock( lock __cfaabi_dbg_ctx2 ); size_t recursion_count = queue_and_get_recursion(this, &info); @@ -340,12 +340,8 @@ void wait( condition_variable(L) & this, L & l, uintptr_t info ) with(this) { WAIT( info, &l ) } - bool wait( condition_variable(L) & this, Duration duration ) with(this) { WAIT_TIME( 0 , 0p , __kernel_get_time() + duration ) } - bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, 0p , __kernel_get_time() + duration ) } - bool wait( condition_variable(L) & this, Time time ) with(this) { WAIT_TIME( 0 , 0p , time ) } - bool wait( condition_variable(L) & this, uintptr_t info, Time time ) with(this) { WAIT_TIME( info, 0p , time ) } - bool wait( condition_variable(L) & this, L & l, Duration duration ) with(this) { WAIT_TIME( 0 , &l , __kernel_get_time() + duration ) } - bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , __kernel_get_time() + duration ) } - bool wait( condition_variable(L) & this, L & l, Time time ) with(this) { WAIT_TIME( 0 , &l , time ) } - bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ) with(this) { WAIT_TIME( info, &l , time ) } + bool wait( condition_variable(L) & this, Duration duration ) with(this) { WAIT_TIME( 0 , 0p , duration ) } + bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, 0p , duration ) } + bool wait( condition_variable(L) & this, L & l, Duration duration ) with(this) { WAIT_TIME( 0 , &l , duration ) } + bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ) with(this) { WAIT_TIME( info, &l , duration ) } } Index: libcfa/src/concurrency/locks.hfa =================================================================== --- libcfa/src/concurrency/locks.hfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/locks.hfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -290,6 +290,4 @@ bool wait( condition_variable(L) & this, Duration duration ); bool wait( condition_variable(L) & this, uintptr_t info, Duration duration ); - bool wait( condition_variable(L) & this, Time time ); - bool wait( condition_variable(L) & this, uintptr_t info, Time time ); void wait( condition_variable(L) & this, L & l ); @@ -297,5 +295,3 @@ bool wait( condition_variable(L) & this, L & l, Duration duration ); bool wait( condition_variable(L) & this, L & l, uintptr_t info, Duration duration ); - bool wait( condition_variable(L) & this, L & l, Time time ); - bool wait( condition_variable(L) & this, L & l, uintptr_t info, Time time ); -} +} Index: libcfa/src/concurrency/preemption.cfa =================================================================== --- libcfa/src/concurrency/preemption.cfa (revision e2f601f4328a2fea1024c253b1f150202c44c9e3) +++ libcfa/src/concurrency/preemption.cfa (revision c457dc41e6b4b62b0efdae9921df595bf3a48d66) @@ -18,4 +18,5 @@ #include "preemption.hfa" + #include @@ -26,4 +27,5 @@ #include // PTHREAD_STACK_MIN +#include "bits/debug.hfa" #include "bits/signal.hfa" #include "kernel_private.hfa" @@ -105,5 +107,5 @@ static inline alarm_node_t * get_expired( alarm_list_t * alarms, Time currtime ) { if( ! & (*alarms)`first ) return 0p; // If no alarms return null - if( (*alarms)`first.alarm >= currtime ) return 0p; // If alarms head not expired return null + if( (*alarms)`first.timeval >= currtime ) return 0p; // If alarms head not expired return null return pop(alarms); // Otherwise just pop head } @@ -141,5 +143,5 @@ if( period > 0 ) { __cfadbg_print_buffer_local( preemption, " KERNEL: alarm period is %lu.\n", period`ns ); - node->alarm = currtime + period; // Alarm is periodic, add currtime to it (used cached current time) + node->timeval = currtime + period; // Alarm is periodic, add currtime to it (used cached current time) insert( alarms, node ); // Reinsert the node for the next time it triggers } @@ -148,7 +150,6 @@ // If there are still alarms pending, reset the timer if( & (*alarms)`first ) { - Duration delta = (*alarms)`first.alarm - currtime; - Duration capped = max(delta, 50`us); - __kernel_set_timer( capped ); + Duration delta = (*alarms)`first.timeval - currtime; + __kernel_set_timer( delta ); } } @@ -160,6 +161,6 @@ // Alarms need to be enabled if ( duration > 0 && ! alarm->set ) { - alarm->alarm = __kernel_get_time() + duration; - alarm->period = duration; + alarm->initial = duration; + alarm->period = duration; register_self( alarm ); } @@ -167,12 +168,12 @@ else if ( duration == 0 && alarm->set ) { unregister_self( alarm ); - alarm->alarm = 0; - alarm->period = 0; + alarm->initial = 0; + alarm->period = 0; } // If alarm is different from previous, change it else if ( duration > 0 && alarm->period != duration ) { unregister_self( alarm ); - alarm->alarm = __kernel_get_time() + duration; - alarm->period = duration; + alarm->initial = duration; + alarm->period = duration; register_self( alarm ); } @@ -599,5 +600,6 @@ // Notify the alarm thread of the shutdown - sigval val = { 1 }; + sigval val; + val.sival_int = 0; pthread_sigqueue( alarm_thread, SIGALRM, val ); @@ -619,5 +621,5 @@ // Used by thread to control when they want to receive preemption signals void ?{}( preemption_scope & this, processor * proc ) { - (this.alarm){ proc, (Time){ 0 }, 0`s }; + (this.alarm){ proc, 0`s, 0`s }; this.proc = proc; this.proc->preemption_alarm = &this.alarm; @@ -705,4 +707,7 @@ int sig = sigwaitinfo( &mask, &info ); + __cfadbg_print_buffer_decl ( preemption, " KERNEL: sigwaitinfo returned %d, c: %d, v: %d\n", sig, info.si_code, info.si_value.sival_int ); + __cfadbg_print_buffer_local( preemption, " KERNEL: SI_QUEUE %d, SI_TIMER %d, SI_KERNEL %d\n", SI_QUEUE, SI_TIMER, SI_KERNEL ); + if( sig < 0 ) { //Error! @@ -711,5 +716,5 @@ case EAGAIN : case EINTR : - {__cfaabi_dbg_print_buffer_decl( " KERNEL: Spurious wakeup %d.\n", err );} + {__cfadbg_print_buffer_local( preemption, " KERNEL: Spurious wakeup %d.\n", err );} continue; case EINVAL : @@ -723,8 +728,19 @@ assertf(sig == SIGALRM, "Kernel Internal Error, sigwait: Unexpected signal %d (%d : %d)\n", sig, info.si_code, info.si_value.sival_int); - // __cfaabi_dbg_print_safe( "Kernel : Caught alarm from %d with %d\n", info.si_code, info.si_value.sival_int ); // Switch on the code (a.k.a. the sender) to switch( info.si_code ) { + // Signal was not sent by the kernel but by an other thread + case SI_QUEUE: + // other threads may signal the alarm thread to shut it down + // or to manual cause the preemption tick + // use info.si_value and handle the case here + switch( info.si_value.sival_int ) { + case 0: + goto EXIT; + default: + abort( "SI_QUEUE with val %d", info.si_value.sival_int); + } + // fallthrough // Timers can apparently be marked as sent for the kernel // In either case, tick preemption @@ -736,9 +752,4 @@ unlock( event_kernel->lock ); break; - // Signal was not sent by the kernel but by an other thread - case SI_QUEUE: - // For now, other thread only signal the alarm thread to shut it down - // If this needs to change use info.si_value and handle the case here - goto EXIT; } }