80468e7c5bwasm/shims/context_sleep.cpp: a main-thread nanosleep whose frame stands on a scheduler context that OWNS the stack arms a mailbox wake and yield_parks that context instead of suspending the stack in place. It lives in the sleep primitive rather than in tool_manager.cpp on purpose - KiCad and the wx core stay untouched (CLAUDE.md's fork rule) and the whole K7 class moves at once, not just TOOL_MANAGER::RunSynchronousAction's spin loop. MEASURED AT D-ON, and it is NOT what unblocks Phase D. The four canvas-tool specs still fail, but the trace now names a different cause: the fatal swap is old=<libcontext ROOT> new=<tool coroutine> with mouseEventHandlerFunc above it - a DOM mouse handler entering wasm DIRECTLY on the main stack, bypassing the tick. So one coroutine is entered two ways: by the tick through the dispatch context as a STAR TRANSFER, and by DOM handlers as a DIRECT SYMMETRIC SWAP. A capture written by one path cannot be rewound by the other -> index out of bounds in doRewind. That is section 7 rule 5 (partial migration is worse than none) in its purest measured form, and it is why the harness stays green: its coroutines are only ever entered from one place. So the next increment is the DOM event entries (mouse/key/wheel/resize must hand their events to the dispatch context as the tick does), not another park site. It subsumes the one-root work too: with no dispatch on the main stack, resolve_root_identity() always answers "the running context". Landing state: STAR_DISPATCH=0, kicad 139 passed / 1 (pre-existing occ-probe) = baseline, with the sleep shim in and inert. Co-Authored-By: Claude Fable 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01LBjomQfKyRa3jBdeAKpmTw
67 lines
3.1 KiB
C
67 lines
3.1 KiB
C
/*
|
|
* nanosleep_yield.c — make a MAIN-THREAD nanosleep() YIELD to the JS event loop via
|
|
* Asyncify instead of busy-spinning, so on-demand pthread-Worker creation can complete
|
|
* WITHOUT editing KiCad.
|
|
*
|
|
* THE PROBLEM (the "non-warm thread" deadlock): once KiCad's thread pool has consumed all
|
|
* the pre-warmed Workers (-sPTHREAD_POOL_SIZE), a later raw std::thread (the raytracer)
|
|
* must spawn a NEW Worker on demand. Finalizing it needs the main thread's event loop to
|
|
* run the new-Worker 'loaded' -> 'run' handshake. KiCad's join is a sleep_for() busy-wait
|
|
* -> nanosleep -> emscripten_thread_sleep, which busy-spins and NEVER returns to the JS
|
|
* event loop, so the new Worker never starts -> deadlock.
|
|
*
|
|
* THE FIX: the only main-thread primitive that returns to the event loop is an Asyncify
|
|
* unwind (emscripten_sleep). This provides a nanosleep that, ON THE MAIN THREAD, yields via
|
|
* an EM_ASYNC_JS await (= emscripten_sleep semantics; __asyncjs__* is already in the
|
|
* post-link asyncify-imports). The unmodified sleep_for busy-wait then pumps the loop, the
|
|
* Worker handshake completes, and on-demand creation works with no KiCad edit.
|
|
*
|
|
* MECHANISM: a STRONG definition of nanosleep here SHADOWS musl's archive member — the
|
|
* linker only pulls musl's nanosleep.o if the symbol is left undefined, and ours defines it.
|
|
* (-Wl,--wrap=nanosleep is not an option here — it crashes wasm-ld with a SIGSEGV in
|
|
* lld::wasm::ImportSection::addImport.) On a pthread worker we fall back to
|
|
* emscripten_thread_sleep (the real underlying blocking sleep — workers may block).
|
|
*
|
|
* SCOPE: only the main browser thread yields; only it must never block the event loop.
|
|
*/
|
|
#include <emscripten/emscripten.h>
|
|
#include <emscripten/threading.h>
|
|
#include <time.h>
|
|
|
|
/* EM_ASYNC_JS integrates with Asyncify automatically (binaryen instruments every caller). */
|
|
EM_ASYNC_JS( void, __wasm_main_thread_yield_ms, ( double ms ), {
|
|
await new Promise( function( resolve ) { setTimeout( resolve, ms ); } );
|
|
} );
|
|
|
|
/*
|
|
* Scheduler-aware sleep (context_sleep.cpp, docs/features/async/22 Phase B):
|
|
* when this frame stands on a scheduler context that owns the stack, the wait
|
|
* PARKS THAT CONTEXT instead of suspending the stack in place. Returns 0 when
|
|
* no context owns the stack, and then the Asyncify yield below is still right.
|
|
*
|
|
* This is what makes TOOL_MANAGER::RunSynchronousAction's spin loop safe under
|
|
* Phase D: an in-place park inside a tool body leaves a capture in flight for a
|
|
* star transfer to land on (doRewind -> "index out of bounds").
|
|
*/
|
|
extern int pcbjam_context_sleep_ms( double ms );
|
|
|
|
int nanosleep( const struct timespec* req, struct timespec* rem )
|
|
{
|
|
if( req )
|
|
{
|
|
double ms = (double) req->tv_sec * 1000.0 + (double) req->tv_nsec / 1.0e6;
|
|
if( emscripten_is_main_runtime_thread() )
|
|
{
|
|
if( !pcbjam_context_sleep_ms( ms ) )
|
|
__wasm_main_thread_yield_ms( ms ); /* yield -> event loop runs -> Worker boots */
|
|
}
|
|
else
|
|
emscripten_thread_sleep( ms ); /* worker: real blocking sleep */
|
|
}
|
|
if( rem )
|
|
{
|
|
rem->tv_sec = 0;
|
|
rem->tv_nsec = 0;
|
|
}
|
|
return 0;
|
|
}
|