Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/alarm.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -89,4 +89,13 @@ } +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 ); @@ -98,4 +107,6 @@ } *p = n; + + LIB_DEBUG_DO( assert( validate( this ) ) ); } @@ -107,4 +118,6 @@ insert_at( this, n, it ); + + LIB_DEBUG_DO( assert( validate( this ) ) ); } @@ -118,4 +131,5 @@ head->next = NULL; } + LIB_DEBUG_DO( assert( validate( this ) ) ); return head; } @@ -123,20 +137,26 @@ static inline void remove_at( alarm_list_t * this, alarm_node_t * n, __alarm_it_t it ) { assert( it ); - assert( (*it)->next == n ); - - (*it)->next = n->next; + assert( (*it) == n ); + + (*it) = n->next; if( !n-> next ) { this->tail = it; } n->next = NULL; + + LIB_DEBUG_DO( assert( 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; } + LIB_DEBUG_DO( assert( validate( this ) ) ); + if( *it ) { remove_at( this, n, it ); } + + LIB_DEBUG_DO( assert( validate( this ) ) ); } @@ -145,4 +165,5 @@ assert( !systemProcessor->pending_alarm ); lock( &systemProcessor->alarm_lock ); + LIB_DEBUG_DO( assert( validate( &systemProcessor->alarms ) ) ); { bool first = !systemProcessor->alarms.head; @@ -158,13 +179,23 @@ unlock( &systemProcessor->alarm_lock ); this->set = true; - enable_interrupts(); + enable_interrupts( __PRETTY_FUNCTION__ ); } void unregister_self( alarm_node_t * this ) { + LIB_DEBUG_DO( + char text[256]; + __attribute__((unused)) int len = snprintf( text, 256, "Kernel : unregister %p start\n", this ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); disable_interrupts(); lock( &systemProcessor->alarm_lock ); + LIB_DEBUG_DO( assert( validate( &systemProcessor->alarms ) ) ); remove( &systemProcessor->alarms, this ); unlock( &systemProcessor->alarm_lock ); disable_interrupts(); this->set = false; -} + LIB_DEBUG_DO( + len = snprintf( text, 256, "Kernel : unregister %p end\n", this ); + LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); + ); +} Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/coroutine.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -32,5 +32,5 @@ #include "invoke.h" -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; //----------------------------------------------------------------------------- Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/invoke.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -31,5 +31,5 @@ extern void __leave_monitor_desc( struct monitor_desc * this ); extern void disable_interrupts(); -extern void enable_interrupts(); +extern void enable_interrupts( const char * ); void CtxInvokeCoroutine( @@ -69,5 +69,5 @@ struct monitor_desc* mon = &thrd->mon; cor->state = Active; - enable_interrupts(); + enable_interrupts( __PRETTY_FUNCTION__ ); // LIB_DEBUG_PRINTF("Invoke Thread : invoking main %p (args %p)\n", main, this); Index: src/libcfa/concurrency/kernel =================================================================== --- src/libcfa/concurrency/kernel (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/kernel (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -90,7 +90,7 @@ unsigned int preemption; - unsigned short disable_preempt_count; + bool pending_preemption; - bool pending_preemption; + char * last_enable; }; Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/kernel.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -59,5 +59,6 @@ // Global state -thread_local processor * this_processor; +volatile thread_local processor * this_processor; +volatile thread_local unsigned short disable_preempt_count; coroutine_desc * this_coroutine(void) { @@ -142,5 +143,4 @@ this->preemption_alarm = NULL; this->preemption = default_preemption(); - this->disable_preempt_count = 1; //Start with interrupts disabled this->pending_preemption = false; @@ -156,5 +156,4 @@ this->preemption_alarm = NULL; this->preemption = default_preemption(); - this->disable_preempt_count = 1; this->pending_preemption = false; this->kernel_thread = pthread_self(); @@ -164,4 +163,6 @@ runner{ this }; } + +LIB_DEBUG_DO( bool validate( alarm_list_t * this ); ) void ?{}(system_proc_t * this, cluster * cltr, processorCtx_t * runner) { @@ -171,4 +172,6 @@ (&this->proc){ cltr, runner }; + + LIB_DEBUG_DO( assert( validate( &this->alarms ) ) ); } @@ -212,5 +215,9 @@ if(readyThread) { + assert( disable_preempt_count > 0 ); + runThread(this, readyThread); + + assert( disable_preempt_count > 0 ); //Some actions need to be taken from the kernel @@ -244,6 +251,4 @@ this->current_thread = dst; - LIB_DEBUG_PRINT_SAFE("Kernel : running %p\n", dst); - // Context Switch to the thread ThreadCtxSwitch(proc_cor, thrd_cor); @@ -294,4 +299,5 @@ processor * proc = (processor *) arg; this_processor = proc; + disable_preempt_count = 1; // SKULLDUGGERY: We want to create a context for the processor coroutine // which is needed for the 2-step context switch. However, there is no reason @@ -381,6 +387,8 @@ void BlockInternal() { disable_interrupts(); + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -389,6 +397,8 @@ this_processor->finish.action_code = Release; this_processor->finish.lock = lock; + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -397,6 +407,8 @@ this_processor->finish.action_code = Schedule; this_processor->finish.thrd = thrd; + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -406,6 +418,8 @@ this_processor->finish.lock = lock; this_processor->finish.thrd = thrd; + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -415,6 +429,8 @@ this_processor->finish.locks = locks; this_processor->finish.lock_count = count; + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -426,6 +442,8 @@ this_processor->finish.thrds = thrds; this_processor->finish.thrd_count = thrd_count; + assert( disable_preempt_count > 0 ); suspend(); - enable_interrupts(); + assert( disable_preempt_count > 0 ); + enable_interrupts( __PRETTY_FUNCTION__ ); } @@ -466,4 +484,5 @@ this_processor->current_thread = mainThread; this_processor->current_coroutine = &mainThread->cor; + disable_preempt_count = 1; // Enable preemption @@ -480,9 +499,11 @@ LIB_DEBUG_PRINT_SAFE("Kernel : Started\n--------------------------------------------------\n\n"); - enable_interrupts(); + enable_interrupts( __PRETTY_FUNCTION__ ); } void kernel_shutdown(void) { LIB_DEBUG_PRINT_SAFE("\n--------------------------------------------------\nKernel : Shutting down\n"); + + disable_interrupts(); // SKULLDUGGERY: Notify the systemProcessor it needs to terminates. @@ -600,7 +621,8 @@ append( &this->blocked, this_thread() ); BlockInternal( &this->lock ); - lock( &this->lock ); - } - unlock( &this->lock ); + } + else { + unlock( &this->lock ); + } } @@ -610,8 +632,10 @@ this->cond = true; + disable_interrupts(); thread_desc * it; while( it = pop_head( &this->blocked) ) { ScheduleThread( it ); } + enable_interrupts( __PRETTY_FUNCTION__ ); } unlock( &this->lock ); Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/kernel_private.h (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -58,10 +58,11 @@ extern cluster * systemCluster; extern system_proc_t * systemProcessor; -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; +extern volatile thread_local unsigned short disable_preempt_count; extern "C" { void disable_interrupts(); void enable_interrupts_noRF(); - void enable_interrupts(); + void enable_interrupts( const char * ); } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/preemption.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -17,7 +17,10 @@ #include "preemption.h" + extern "C" { #include +#define __USE_GNU #include +#undef __USE_GNU #include #include @@ -60,5 +63,10 @@ sigprocmask( SIG_BLOCK, &mask, NULL ); LIB_DEBUG_PRINT_SAFE("Kernel : Preemption stopped\n"); -} + + assert( !systemProcessor->alarms.head ); + assert( systemProcessor->alarms.tail == &systemProcessor->alarms.head ); +} + +LIB_DEBUG_DO( bool validate( alarm_list_t * this ); ) void tick_preemption() { @@ -84,4 +92,6 @@ } + LIB_DEBUG_DO( assert( validate( alarms ) ) ); + if( node->period > 0 ) { node->alarm = currtime + node->period; @@ -98,4 +108,5 @@ LIB_DEBUG_DO( + assert( validate( alarms ) ); len = snprintf( text, 256, "Ticking preemption done\n" ); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); @@ -106,5 +117,5 @@ LIB_DEBUG_DO( char text[256]; - __attribute__((unused)) int len = snprintf( text, 256, "Processor : updating preemption to %lu\n", duration ); + __attribute__((unused)) int len = snprintf( text, 256, "Processor : %p updating preemption to %lu\n", this, duration ); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); ); @@ -139,6 +150,4 @@ this->proc->preemption_alarm = &this->alarm; update_preemption( this->proc, this->proc->preemption ); - - // enable_interrupts(); } @@ -155,15 +164,16 @@ extern "C" { void disable_interrupts() { - __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, 1, __ATOMIC_SEQ_CST ); - assert( prev != (unsigned short) -1 ); + __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST ); + assert( new_val < (unsigned short)65_000 ); + assert( new_val != (unsigned short) 0 ); } void enable_interrupts_noRF() { - unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); assert( prev != (unsigned short) 0 ); } - void enable_interrupts() { - unsigned short prev = __atomic_fetch_add_2( &this_processor->disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + void enable_interrupts( const char * func ) { + unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); assert( prev != (unsigned short) 0 ); if( prev == 1 && this_processor->pending_preemption ) { @@ -171,9 +181,11 @@ LIB_DEBUG_DO( char text[256]; - __attribute__((unused)) int len = snprintf( text, 256, "Executing deferred CtxSwitch\n" ); + __attribute__((unused)) int len = snprintf( text, 256, "Executing deferred CtxSwitch on %p\n", this_processor ); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); ); BlockInternal( this_processor->current_thread ); } + + this_processor->last_enable = func; } } @@ -192,5 +204,5 @@ static inline bool preemption_ready() { - return this_processor->disable_preempt_count == 0; + return disable_preempt_count == 0; } @@ -207,5 +219,5 @@ LIB_DEBUG_DO( char text[256]; - __attribute__((unused)) int len = snprintf( text, 256, "Ctx Switch IRH\n" ); + __attribute__((unused)) int len = snprintf( text, 256, "Ctx Switch IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP])); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); ); @@ -214,5 +226,5 @@ if( preemption_ready() ) { LIB_DEBUG_DO( - len = snprintf( text, 256, "Ctx Switch IRH : Blocking thread\n" ); + len = snprintf( text, 256, "Ctx Switch IRH : Blocking thread %p on %p\n", this_processor->current_thread, this_processor ); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); ); @@ -232,5 +244,5 @@ LIB_DEBUG_DO( char text[256]; - __attribute__((unused)) int len = snprintf( text, 256, "\nAlarm IRH\n" ); + __attribute__((unused)) int len = snprintf( text, 256, "\nAlarm IRH %p\n", (void *)(cxt->uc_mcontext.gregs[REG_RIP]) ); LIB_DEBUG_WRITE( STDERR_FILENO, text, len ); ); Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision 70c2df8956e2ed7d355766b92857702ad9b8ed74) +++ src/libcfa/concurrency/thread.c (revision 4e6fb8e098f18742d8fbe318ca33b1e972b3f0c8) @@ -28,5 +28,5 @@ } -extern thread_local processor * this_processor; +extern volatile thread_local processor * this_processor; //-----------------------------------------------------------------------------