Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision b2b44d808ae1e94cb906efa6dd7aebd115204e3b) +++ src/libcfa/concurrency/kernel.c (revision 43bbdf35433867f116ecf5b801b35ec007e3e2aa) @@ -59,4 +59,5 @@ volatile thread_local bool preemption_in_progress = 0; +volatile thread_local bool preemption_enabled = false; volatile thread_local unsigned short disable_preempt_count = 1; @@ -196,9 +197,9 @@ if(readyThread) { - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); runThread(this, readyThread); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); //Some actions need to be taken from the kernel @@ -242,5 +243,5 @@ void finishRunning(processor * this) with( this->finish ) { if( action_code == Release ) { - verify( disable_preempt_count > 1 ); + verify( !preemption_enabled ); unlock( *lock ); } @@ -249,10 +250,10 @@ } else if( action_code == Release_Schedule ) { - verify( disable_preempt_count > 1 ); + verify( !preemption_enabled ); unlock( *lock ); ScheduleThread( thrd ); } else if( action_code == Release_Multi ) { - verify( disable_preempt_count > lock_count ); + verify( !preemption_enabled ); for(int i = 0; i < lock_count; i++) { unlock( *locks[i] ); @@ -286,4 +287,5 @@ this_coroutine = NULL; this_thread = NULL; + preemption_enabled = false; disable_preempt_count = 1; // SKULLDUGGERY: We want to create a context for the processor coroutine @@ -333,5 +335,5 @@ verify( thrd->self_cor.state != Halted ); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); @@ -343,13 +345,13 @@ } - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); } thread_desc * nextThread(cluster * this) with( *this ) { - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); lock( ready_queue_lock __cfaabi_dbg_ctx2 ); thread_desc * head = pop_head( ready_queue ); unlock( ready_queue_lock ); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); return head; } @@ -357,7 +359,7 @@ void BlockInternal() { disable_interrupts(); - verify( disable_preempt_count > 0 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); } @@ -368,7 +370,7 @@ this_processor->finish.lock = lock; - verify( disable_preempt_count > 1 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -380,7 +382,7 @@ this_processor->finish.thrd = thrd; - verify( disable_preempt_count > 0 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -394,7 +396,7 @@ this_processor->finish.thrd = thrd; - verify( disable_preempt_count > 1 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -407,7 +409,7 @@ this_processor->finish.lock_count = count; - verify( disable_preempt_count > 0 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -422,7 +424,7 @@ this_processor->finish.thrd_count = thrd_count; - verify( disable_preempt_count > 0 ); - suspend(); - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); + suspend(); + verify( !preemption_enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -430,5 +432,5 @@ void LeaveThread(__spinlock_t * lock, thread_desc * thrd) { - verify( disable_preempt_count > 0 ); + verify( !preemption_enabled ); this_processor->finish.action_code = thrd ? Release_Schedule : Release; this_processor->finish.lock = lock; Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision b2b44d808ae1e94cb906efa6dd7aebd115204e3b) +++ src/libcfa/concurrency/kernel_private.h (revision 43bbdf35433867f116ecf5b801b35ec007e3e2aa) @@ -74,4 +74,5 @@ extern volatile thread_local bool preemption_in_progress; +extern volatile thread_local bool preemption_enabled; extern volatile thread_local unsigned short disable_preempt_count; Index: src/libcfa/concurrency/monitor.c =================================================================== --- src/libcfa/concurrency/monitor.c (revision b2b44d808ae1e94cb906efa6dd7aebd115204e3b) +++ src/libcfa/concurrency/monitor.c (revision 43bbdf35433867f116ecf5b801b35ec007e3e2aa) @@ -87,6 +87,4 @@ thread_desc * thrd = this_thread; - verify( disable_preempt_count > 0 ); - __cfaabi_dbg_print_safe("Kernel : %10p Entering mon %p (%p)\n", thrd, this, this->owner); @@ -117,6 +115,4 @@ // Some one else has the monitor, wait in line for it append( this->entry_queue, thrd ); - - verify( disable_preempt_count > 0 ); BlockInternal( &this->lock ); @@ -396,11 +392,6 @@ append( this.blocked, &waiter ); - verify( disable_preempt_count == 0 ); - // Lock all monitors (aggregates the locks as well) lock_all( monitors, locks, count ); - - // verifyf( disable_preempt_count == count, "Got %d, expected %d\n", disable_preempt_count, count ); - if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } // Find the next thread(s) to run @@ -477,11 +468,6 @@ monitor_ctx( this.monitors, this.monitor_count ); - verify( disable_preempt_count == 0 ); - // Lock all monitors (aggregates the locks them as well) lock_all( monitors, locks, count ); - - // verify( disable_preempt_count == count ); - if(disable_preempt_count != count) { __cfaabi_dbg_print_buffer_decl("----------Gonna crash\n"); } Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision b2b44d808ae1e94cb906efa6dd7aebd115204e3b) +++ src/libcfa/concurrency/preemption.c (revision 43bbdf35433867f116ecf5b801b35ec007e3e2aa) @@ -142,5 +142,7 @@ // Disable interrupts by incrementing the counter void disable_interrupts() { - __attribute__((unused)) unsigned short new_val = __atomic_add_fetch_2( &disable_preempt_count, 1, __ATOMIC_SEQ_CST ); + preemption_enabled = false; + __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1; + disable_preempt_count = new_val; verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them } @@ -152,11 +154,15 @@ thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add - unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + unsigned short prev = disable_preempt_count; + disable_preempt_count -= 1; verify( prev != 0u ); // If this triggers someone is enabled already enabled interruptsverify( prev != 0u ); // Check if we need to prempt the thread because an interrupt was missed - if( prev == 1 && proc->pending_preemption ) { - proc->pending_preemption = false; - BlockInternal( thrd ); + if( prev == 1 ) { + preemption_enabled = true; + if( proc->pending_preemption ) { + proc->pending_preemption = false; + BlockInternal( thrd ); + } } @@ -168,6 +174,10 @@ // Don't execute any pending CtxSwitch even if counter reaches 0 void enable_interrupts_noPoll() { - __attribute__((unused)) unsigned short prev = __atomic_fetch_add_2( &disable_preempt_count, -1, __ATOMIC_SEQ_CST ); + unsigned short prev = disable_preempt_count; + disable_preempt_count -= 1; verifyf( prev != 0u, "Incremented from %u\n", prev ); // If this triggers someone is enabled already enabled interrupts + if( prev == 1 ) { + preemption_enabled = true; + } } } @@ -210,5 +220,5 @@ // If false : preemption is unsafe and marked as pending static inline bool preemption_ready() { - bool ready = disable_preempt_count == 0 && !preemption_in_progress; // Check if preemption is safe + bool ready = preemption_enabled && !preemption_in_progress; // Check if preemption is safe this_processor->pending_preemption = !ready; // Adjust the pending flag accordingly return ready; @@ -225,4 +235,5 @@ // Start with preemption disabled until ready + preemption_enabled = false; disable_preempt_count = 1;