Index: src/libcfa/bits/cfatime.h =================================================================== --- src/libcfa/bits/cfatime.h (revision b69ea6b554214dcd325045f0da798f46a485fa59) +++ src/libcfa/bits/cfatime.h (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -0,0 +1,93 @@ +// +// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo +// +// The contents of this file are covered under the licence agreement in the +// file "LICENCE" distributed with Cforall. +// +// align.h -- +// +// Author : Thierry Delisle +// Created On : Mon Feb 12 18:06:59 2018 +// Last Modified By : +// Last Modified On : +// Update Count : 0 +// +// This library is free software; you can redistribute it and/or modify it +// under the terms of the GNU Lesser General Public License as published by the +// Free Software Foundation; either version 2.1 of the License, or (at your +// option) any later version. +// +// This library is distributed in the hope that it will be useful, but WITHOUT +// ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or +// FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License +// for more details. +// +// You should have received a copy of the GNU Lesser General Public License +// along with this library. +// + +#pragma once + +extern "C" { +#include +} + +#include "bits/defs.h" + +struct timespec; +struct itimerval; + +//============================================================================================= +// time type +//============================================================================================= + +struct __cfa_time_t { + uint64_t val; +}; + +// ctors +static inline void ?{}( __cfa_time_t & this ) { this.val = 0; } +static inline void ?{}( __cfa_time_t & this, zero_t zero ) { this.val = 0; } + +static inline __cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ) { + this.val = 0; + return this; +} + +// logical ops +static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; } +static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; } +static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val > rhs.val; } +static inline bool ?=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; } +static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; } + +static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; } +static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; } +static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val > rhs; } +static inline bool ?=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; } +static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; } + +// addition/substract +static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) { + __cfa_time_t ret; + ret.val = lhs.val + rhs.val; + return ret; +} + +static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) { + __cfa_time_t ret; + ret.val = lhs.val - rhs.val; + return ret; +} + +static inline __cfa_time_t ?`cfa_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; } +static inline __cfa_time_t ?`cfa_ms( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000ul; return ret; } +static inline __cfa_time_t ?`cfa_us( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000ul; return ret; } +static inline __cfa_time_t ?`cfa_ns( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1ul; return ret; } + +static inline __cfa_time_t from_s ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000_000ul; return ret; } +static inline __cfa_time_t from_ms ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000_000ul; return ret; } +static inline __cfa_time_t from_us ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1_000ul; return ret; } +static inline __cfa_time_t from_ns ( uint64_t val ) { __cfa_time_t ret; ret.val = val * 1ul; return ret; } Index: src/libcfa/concurrency/alarm.c =================================================================== --- src/libcfa/concurrency/alarm.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/alarm.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -18,5 +18,4 @@ #include #include -#include #include #include @@ -27,41 +26,17 @@ #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 ) with( this ) { - it_value.tv_sec = alarm->val / one_second; // seconds - it_value.tv_usec = max( (alarm->val % one_second) / one_microsecond, 1000 ); // microseconds +static inline void ?{}( itimerval & this, __cfa_time_t * alarm ) with( this ) { + it_value.tv_sec = alarm->val / (1`cfa_s).val; // seconds + it_value.tv_usec = max( (alarm->val % (1`cfa_s).val) / (1`cfa_us).val, 1000 ); // microseconds it_interval.tv_sec = 0; it_interval.tv_usec = 0; } - -void ?{}( __cfa_time_t & this, timespec * curr ) { +static inline 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; + this.val = from_s(secs).val + 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; } //============================================================================================= @@ -84,5 +59,5 @@ //============================================================================================= -void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) with( this ) { +void ?{}( alarm_node_t & this, thread_desc * thrd, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) { this.thrd = thrd; this.alarm = alarm; @@ -93,5 +68,5 @@ } -void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = zero_time, __cfa_time_t period = zero_time ) with( this ) { +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ) with( this ) { this.proc = proc; this.alarm = alarm; Index: src/libcfa/concurrency/alarm.h =================================================================== --- src/libcfa/concurrency/alarm.h (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/alarm.h (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -21,60 +21,8 @@ #include +#include "bits/cfatime.h" + struct thread_desc; struct processor; - -struct timespec; -struct itimerval; - -//============================================================================================= -// time type -//============================================================================================= - -struct __cfa_time_t { - uint64_t val; -}; - -// ctors -void ?{}( __cfa_time_t & this ); -void ?{}( __cfa_time_t & this, zero_t zero ); -void ?{}( __cfa_time_t & this, timespec * curr ); -void ?{}( itimerval & this, __cfa_time_t * alarm ); - -__cfa_time_t ?=?( __cfa_time_t & this, zero_t rhs ); - -// logical ops -static inline bool ?==?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val == rhs.val; } -static inline bool ?!=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val != rhs.val; } -static inline bool ?>? ( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val > rhs.val; } -static inline bool ?=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val >= rhs.val; } -static inline bool ?<=?( __cfa_time_t lhs, __cfa_time_t rhs ) { return lhs.val <= rhs.val; } - -static inline bool ?==?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val == rhs; } -static inline bool ?!=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val != rhs; } -static inline bool ?>? ( __cfa_time_t lhs, zero_t rhs ) { return lhs.val > rhs; } -static inline bool ?=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val >= rhs; } -static inline bool ?<=?( __cfa_time_t lhs, zero_t rhs ) { return lhs.val <= rhs; } - -// addition/substract -static inline __cfa_time_t ?+?( __cfa_time_t lhs, __cfa_time_t rhs ) { - __cfa_time_t ret; - ret.val = lhs.val + rhs.val; - return ret; -} - -static inline __cfa_time_t ?-?( __cfa_time_t lhs, __cfa_time_t rhs ) { - __cfa_time_t ret; - ret.val = lhs.val - rhs.val; - return ret; -} - -__cfa_time_t from_s ( uint64_t ); -__cfa_time_t from_ms( uint64_t ); -__cfa_time_t from_us( uint64_t ); -__cfa_time_t from_ns( uint64_t ); - -extern __cfa_time_t zero_time; //============================================================================================= @@ -105,6 +53,6 @@ typedef alarm_node_t ** __alarm_it_t; -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, processor * proc, __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_s, __cfa_time_t period = 0`cfa_s ); +void ?{}( alarm_node_t & this, processor * proc, __cfa_time_t alarm = 0`cfa_s, __cfa_time_t period = 0`cfa_s ); void ^?{}( alarm_node_t & this ); Index: src/libcfa/concurrency/coroutine.c =================================================================== --- src/libcfa/concurrency/coroutine.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/coroutine.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -99,4 +99,5 @@ // Wrapper for co void CoroutineCtxSwitch(coroutine_desc* src, coroutine_desc* dst) { + verify( preemption.enabled || this_processor->do_terminate ); disable_interrupts(); @@ -116,4 +117,5 @@ enable_interrupts( __cfaabi_dbg_ctx ); + verify( preemption.enabled || this_processor->do_terminate ); } //ctxSwitchDirect Index: src/libcfa/concurrency/invoke.c =================================================================== --- src/libcfa/concurrency/invoke.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/invoke.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -28,4 +28,5 @@ extern void __suspend_internal(void); extern void __leave_coroutine(void); +extern void __finish_creation(void); extern void __leave_thread_monitor( struct thread_desc * this ); extern void disable_interrupts(); @@ -44,4 +45,6 @@ cor->state = Active; + + enable_interrupts( __cfaabi_dbg_ctx ); main( this ); @@ -62,5 +65,5 @@ // First suspend, once the thread arrives here, // the function pointer to main can be invalidated without risk - __suspend_internal(); + __finish_creation(); // Fetch the thread handle from the user defined thread structure Index: src/libcfa/concurrency/kernel.c =================================================================== --- src/libcfa/concurrency/kernel.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/kernel.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -56,7 +56,9 @@ thread_local processor * volatile this_processor; -volatile thread_local bool preemption_in_progress = 0; -volatile thread_local bool preemption_enabled = false; -volatile thread_local unsigned short disable_preempt_count = 1; +// volatile thread_local bool preemption_in_progress = 0; +// volatile thread_local bool preemption_enabled = false; +// volatile thread_local unsigned short disable_preempt_count = 1; + +volatile thread_local __cfa_kernel_preemption_data_t preemption = { false, false, 1 }; //----------------------------------------------------------------------------- @@ -207,9 +209,9 @@ if(readyThread) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); runThread(this, readyThread); - verify( !preemption_enabled ); + verify( !preemption.enabled ); //Some actions need to be taken from the kernel @@ -260,5 +262,5 @@ void finishRunning(processor * this) with( this->finish ) { if( action_code == Release ) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); unlock( *lock ); } @@ -267,10 +269,10 @@ } else if( action_code == Release_Schedule ) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); unlock( *lock ); ScheduleThread( thrd ); } else if( action_code == Release_Multi ) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); for(int i = 0; i < lock_count; i++) { unlock( *locks[i] ); @@ -304,6 +306,6 @@ this_coroutine = NULL; this_thread = NULL; - preemption_enabled = false; - disable_preempt_count = 1; + preemption.enabled = false; + preemption.disable_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 @@ -345,4 +347,42 @@ } +void kernel_first_resume(processor * this) { + coroutine_desc * src = this_coroutine; + coroutine_desc * dst = get_coroutine(*this->runner); + + verify( !preemption.enabled ); + + create_stack(&dst->stack, dst->stack.size); + CtxStart(this->runner, CtxInvokeCoroutine); + + verify( !preemption.enabled ); + + dst->last = src; + dst->starter = dst->starter ? dst->starter : src; + + // set state of current coroutine to inactive + src->state = src->state == Halted ? Halted : Inactive; + + // set new coroutine that task is executing + this_coroutine = dst; + + // SKULLDUGGERY normally interrupts are enable before leaving a coroutine ctxswitch. + // Therefore, when first creating a coroutine, interrupts are enable before calling the main. + // This is consistent with thread creation. However, when creating the main processor coroutine, + // we wan't interrupts to be disabled. Therefore, we double-disable interrupts here so they will + // stay disabled. + disable_interrupts(); + + // context switch to specified coroutine + assert( src->stack.context ); + CtxSwitch( src->stack.context, dst->stack.context ); + // when CtxSwitch returns we are back in the src coroutine + + // set state of new coroutine to active + src->state = Active; + + verify( !preemption.enabled ); +} + //----------------------------------------------------------------------------- // Scheduler routines @@ -352,5 +392,5 @@ verify( thrd->self_cor.state != Halted ); - verify( !preemption_enabled ); + verify( !preemption.enabled ); verifyf( thrd->next == NULL, "Expected null got %p", thrd->next ); @@ -362,13 +402,13 @@ } - verify( !preemption_enabled ); + verify( !preemption.enabled ); } thread_desc * nextThread(cluster * this) with( *this ) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); lock( ready_queue_lock __cfaabi_dbg_ctx2 ); thread_desc * head = pop_head( ready_queue ); unlock( ready_queue_lock ); - verify( !preemption_enabled ); + verify( !preemption.enabled ); return head; } @@ -376,7 +416,7 @@ void BlockInternal() { disable_interrupts(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); } @@ -387,7 +427,7 @@ this_processor->finish.lock = lock; - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -399,7 +439,7 @@ this_processor->finish.thrd = thrd; - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -413,7 +453,7 @@ this_processor->finish.thrd = thrd; - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -426,7 +466,7 @@ this_processor->finish.lock_count = count; - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -441,7 +481,7 @@ this_processor->finish.thrd_count = thrd_count; - verify( !preemption_enabled ); + verify( !preemption.enabled ); returnToKernel(); - verify( !preemption_enabled ); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); @@ -449,5 +489,5 @@ void LeaveThread(__spinlock_t * lock, thread_desc * thrd) { - verify( !preemption_enabled ); + verify( !preemption.enabled ); this_processor->finish.action_code = thrd ? Release_Schedule : Release; this_processor->finish.lock = lock; @@ -463,4 +503,5 @@ // Kernel boot procedures void kernel_startup(void) { + verify( !preemption.enabled ); __cfaabi_dbg_print_safe("Kernel : Starting\n"); @@ -500,5 +541,5 @@ // context. Hence, the main thread does not begin through CtxInvokeThread, like all other threads. The trick here is that // mainThread is on the ready queue when this call is made. - resume( *mainProcessor->runner ); + kernel_first_resume( this_processor ); @@ -507,5 +548,7 @@ __cfaabi_dbg_print_safe("Kernel : Started\n--------------------------------------------------\n\n"); + verify( !preemption.enabled ); enable_interrupts( __cfaabi_dbg_ctx ); + verify( preemption.enabled ); } @@ -513,5 +556,7 @@ __cfaabi_dbg_print_safe("\n--------------------------------------------------\nKernel : Shutting down\n"); + verify( preemption.enabled ); disable_interrupts(); + verify( !preemption.enabled ); // SKULLDUGGERY: Notify the mainProcessor it needs to terminates. Index: src/libcfa/concurrency/kernel_private.h =================================================================== --- src/libcfa/concurrency/kernel_private.h (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/kernel_private.h (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -74,7 +74,15 @@ extern thread_local processor * volatile this_processor; -extern volatile thread_local bool preemption_in_progress; -extern volatile thread_local bool preemption_enabled; -extern volatile thread_local unsigned short disable_preempt_count; +// extern volatile thread_local bool preemption_in_progress; +// extern volatile thread_local bool preemption_enabled; +// extern volatile thread_local unsigned short disable_preempt_count; + +struct __cfa_kernel_preemption_data_t { + bool enabled; + bool in_progress; + unsigned short disable_count; +}; + +extern volatile thread_local __cfa_kernel_preemption_data_t preemption; //----------------------------------------------------------------------------- Index: src/libcfa/concurrency/preemption.c =================================================================== --- src/libcfa/concurrency/preemption.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/preemption.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -149,7 +149,7 @@ // Disable interrupts by incrementing the counter void disable_interrupts() { - preemption_enabled = false; - __attribute__((unused)) unsigned short new_val = disable_preempt_count + 1; - disable_preempt_count = new_val; + preemption.enabled = false; + __attribute__((unused)) unsigned short new_val = preemption.disable_count + 1; + preemption.disable_count = new_val; verify( new_val < 65_000u ); // If this triggers someone is disabling interrupts without enabling them } @@ -161,11 +161,11 @@ thread_desc * thrd = this_thread; // Cache the thread now since interrupts can start happening after the atomic add - unsigned short prev = disable_preempt_count; - disable_preempt_count -= 1; + unsigned short prev = preemption.disable_count; + preemption.disable_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 ) { - preemption_enabled = true; + preemption.enabled = true; if( proc->pending_preemption ) { proc->pending_preemption = false; @@ -181,9 +181,9 @@ // Don't execute any pending CtxSwitch even if counter reaches 0 void enable_interrupts_noPoll() { - unsigned short prev = disable_preempt_count; - disable_preempt_count -= 1; + unsigned short prev = preemption.disable_count; + preemption.disable_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; + preemption.enabled = true; } } @@ -235,5 +235,5 @@ // If false : preemption is unsafe and marked as pending static inline bool preemption_ready() { - bool ready = preemption_enabled && !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; @@ -250,6 +250,6 @@ // Start with preemption disabled until ready - preemption_enabled = false; - disable_preempt_count = 1; + preemption.enabled = false; + preemption.disable_count = 1; // Initialize the event kernel @@ -290,5 +290,5 @@ // Used by thread to control when they want to receive preemption signals void ?{}( preemption_scope & this, processor * proc ) { - (this.alarm){ proc, zero_time, zero_time }; + (this.alarm){ proc, 0`cfa_s, 0`cfa_s }; this.proc = proc; this.proc->preemption_alarm = &this.alarm; @@ -300,5 +300,5 @@ disable_interrupts(); - update_preemption( this.proc, zero_time ); + update_preemption( this.proc, 0`cfa_s ); } @@ -330,7 +330,7 @@ __cfaabi_dbg_print_buffer_decl( " KERNEL: preempting core %p (%p).\n", this_processor, this_thread); - preemption_in_progress = true; // Sync flag : prevent recursive calls to the signal handler + preemption.in_progress = true; // Sync flag : prevent recursive calls to the signal handler signal_unblock( SIGUSR1 ); // We are about to CtxSwitch out of the signal handler, let other handlers in - preemption_in_progress = false; // Clear the in progress flag + preemption.in_progress = false; // Clear the in progress flag // Preemption can occur here Index: src/libcfa/concurrency/thread.c =================================================================== --- src/libcfa/concurrency/thread.c (revision 2fdbb3b7e07241973e885a3cad18dde21e5e8d12) +++ src/libcfa/concurrency/thread.c (revision b69ea6b554214dcd325045f0da798f46a485fa59) @@ -90,6 +90,15 @@ } +extern "C" { + void __finish_creation(void) { + coroutine_desc* thrd_c = this_coroutine; + ThreadCtxSwitch( thrd_c, thrd_c->last ); + } +} + void yield( void ) { + verify( preemption.enabled ); BlockInternal( this_thread ); + verify( preemption.enabled ); }