From 9b5c5b9ff474b48e877137e8569fcd0cc4b23d2e Mon Sep 17 00:00:00 2001 From: Andrei Alexeyev Date: Wed, 12 Aug 2020 04:07:20 +0300 Subject: [PATCH] Remove fastcomp-specific Asyncify code (#11868) See #11860 --- src/library_async.js | 225 +--------------------------------------- src/library_idbstore.js | 4 +- src/library_sdl.js | 4 +- src/library_syscall.js | 4 +- src/postamble.js | 8 +- src/preamble.js | 8 +- 6 files changed, 15 insertions(+), 238 deletions(-) diff --git a/src/library_async.js b/src/library_async.js index 1163a9e7c849a..6478d3338bf7b 100644 --- a/src/library_async.js +++ b/src/library_async.js @@ -20,228 +20,6 @@ mergeInto(LibraryManager.library, { }, #if ASYNCIFY -#if !WASM_BACKEND -/* - * The layout of normal and async stack frames - * - * --------------------- <-- saved sp for the current function - * - * --------------------- - * pointer to the previous frame <-- __async_cur_frame - * saved sp - * callback function <-- ctx, returned by alloc/reallloc, used by the program - * saved local variable1 - * saved local variable2 - * ... - * --------------------- <-- STACKTOP - * - */ - __async: 0, // whether a truly async function has been called - __async_unwind: 1, // whether to unwind the async stack frame - __async_retval: '{{{ makeStaticAlloc(2) }}}', // store the return value for async functions - __async_cur_frame: 0, // address to the current frame, which stores previous frame, stack pointer and async context - - // __async_retval is not actually required in emscripten_async_resume - // but we want it included when ASYNCIFY is enabled - emscripten_async_resume__deps: ['__async', '__async_unwind', '__async_retval', '__async_cur_frame'], - emscripten_async_resume__sig: 'v', - emscripten_async_resume__asm: true, - emscripten_async_resume: function() { - var callback = 0; - ___async = 0; - ___async_unwind = 1; - while (1) { - if (!___async_cur_frame) return; - callback = {{{ makeGetValueAsm('___async_cur_frame', 8, 'i32') }}}; - // the signature of callback is always vi - // the only argument is ctx - {{{ makeDynCall('vi') }}}(callback | 0, (___async_cur_frame + 8)|0); - if (___async) return; // that was an async call - if (!___async_unwind) { - // keep the async stack - ___async_unwind = 1; - continue; - } - // unwind normal stack frame - stackRestore({{{ makeGetValueAsm('___async_cur_frame', 4, 'i32') }}}); - // pop the last async stack frame - ___async_cur_frame = {{{ makeGetValueAsm('___async_cur_frame', 0, 'i32') }}}; - } - }, - - emscripten_sleep__deps: ['emscripten_async_resume', '$Browser'], - emscripten_sleep: function(ms) { - Module['setAsync'](); // tell the scheduler that we have a callback on hold - Browser.safeSetTimeout(_emscripten_async_resume, ms); - }, - - emscripten_alloc_async_context__deps: ['__async_cur_frame'], - emscripten_alloc_async_context__sig: 'iii', - emscripten_alloc_async_context__asm: true, - emscripten_alloc_async_context: function(len, sp) { - len = len|0; - sp = sp|0; - // len is the size of ctx - // we also need to store prev_frame, stack pointer before ctx - var new_frame = 0; new_frame = stackAlloc((len + 8)|0)|0; - // save sp - {{{ makeSetValueAsm('new_frame', 4, 'sp', 'i32') }}}; - // link the frame with previous one - {{{ makeSetValueAsm('new_frame', 0, '___async_cur_frame', 'i32') }}}; - ___async_cur_frame = new_frame; - return (___async_cur_frame + 8)|0; - }, - - emscripten_realloc_async_context__deps: ['__async_cur_frame'], - emscripten_realloc_async_context__sig: 'ii', - emscripten_realloc_async_context__asm: true, - emscripten_realloc_async_context: function(len) { - len = len|0; - // assuming that we have on the stacktop - stackRestore(___async_cur_frame | 0); - return ((stackAlloc((len + 8)|0)|0) + 8)|0; - }, - - emscripten_free_async_context__deps: ['__async_cur_frame'], - emscripten_free_async_context__sig: 'vi', - emscripten_free_async_context__asm: true, - emscripten_free_async_context: function(ctx) { - // this function is called when a possibly async function turned out to be sync - // just undo a recent emscripten_alloc_async_context - ctx = ctx|0; -#if ASSERTIONS - if ((((___async_cur_frame + 8)|0) != (ctx|0))|0) abort(); -#endif - stackRestore(___async_cur_frame | 0); - ___async_cur_frame = {{{ makeGetValueAsm('___async_cur_frame', 0, 'i32') }}}; - }, - - emscripten_check_async: true, - emscripten_do_not_unwind: true, - emscripten_do_not_unwind_async: true, - - emscripten_get_async_return_value_addr__deps: ['__async_retval'], - emscripten_get_async_return_value_addr: true, - -/* - * Layout of an ASYNCIFY coroutine structure - * - * 0 callee's async ctx - * 4 callee's STACKTOP - * 8 callee's STACK_MAX - * 12 my async ctx - * 16 my STACKTOP - * 20 my stack size - * 24 coroutine function - * 28 coroutine arg - * 32 my stack: - * ... - */ - emscripten_coroutine_create__sig: 'iiii', - emscripten_coroutine_create__asm: true, - emscripten_coroutine_create__deps: ['malloc', 'emscripten_alloc_async_context'], - emscripten_coroutine_create: function(f, arg, stack_size) { - f = f|0; - arg = arg|0; - stack_size = stack_size|0; - var coroutine = 0; - - if ((stack_size|0) <= 0) stack_size = 4096; - - coroutine = _malloc(stack_size + 32 | 0) | 0; - {{{ makeSetValueAsm('coroutine', 12, 0, 'i32') }}}; - {{{ makeSetValueAsm('coroutine', 16, '(coroutine+32)', 'i32') }}}; - {{{ makeSetValueAsm('coroutine', 20, 'stack_size', 'i32') }}}; - {{{ makeSetValueAsm('coroutine', 24, 'f', 'i32') }}}; - {{{ makeSetValueAsm('coroutine', 28, 'arg', 'i32') }}}; - return coroutine|0; - }, - emscripten_coroutine_next__sig: 'ii', - emscripten_coroutine_next__asm: true, - emscripten_coroutine_next__deps: ['__async_cur_frame', '__async', 'emscripten_async_resume', 'free'], - emscripten_coroutine_next: function(coroutine) { - coroutine = coroutine|0; - var coroutine_not_finished = 0, temp = 0; - // switch context - {{{ makeSetValueAsm('coroutine', 0, '___async_cur_frame', 'i32') }}}; - temp = stackSave() | 0; - {{{ makeSetValueAsm('coroutine', 4, 'temp', 'i32') }}}; - {{{ makeSetValueAsm('coroutine', 8, 'STACK_MAX', 'i32') }}}; - ___async_cur_frame = {{{ makeGetValueAsm('coroutine', 12, 'i32') }}}; - stackRestore({{{ makeGetValueAsm('coroutine', 16, 'i32') }}}); - STACK_MAX = coroutine + 32 + {{{ makeGetValueAsm('coroutine', 20, 'i32') }}} | 0; - - if (!___async_cur_frame) { - // first run - {{{ makeDynCall('vi') }}}( - {{{ makeGetValueAsm('coroutine', 24, 'i32') }}}, - {{{ makeGetValueAsm('coroutine', 28, 'i32') }}} - ); - } else { - _emscripten_async_resume(); - } - - // switch context - {{{ makeSetValueAsm('coroutine', 12, '___async_cur_frame', 'i32') }}}; - temp = stackSave() | 0; - {{{ makeSetValueAsm('coroutine', 16, 'temp', 'i32') }}}; - ___async_cur_frame = {{{ makeGetValueAsm('coroutine', 0, 'i32') }}}; - stackRestore({{{ makeGetValueAsm('coroutine', 4, 'i32') }}}); - STACK_MAX = {{{ makeGetValueAsm('coroutine', 8, 'i32') }}}; - - coroutine_not_finished = ___async; - if (!coroutine_not_finished) { - // coroutine has finished - _free(coroutine); - } - // coroutine may be created during an async function - // we do not want to affect the original async ctx - // strictly we should backup and restore ___async, ___async_retval and ___async_unwind - // but ___async=0 seems enough - ___async = 0; - - return coroutine_not_finished|0; - }, - emscripten_yield__sig: 'v', - emscripten_yield__asm: true, - emscripten_yield: function() { - ___async = 1; - }, - - emscripten_wget__deps: ['emscripten_async_resume', '$PATH_FS', '$Browser'], - emscripten_wget: function(url, file) { - var _url = UTF8ToString(url); - var _file = UTF8ToString(file); - _file = PATH_FS.resolve(FS.cwd(), _file); - Module['setAsync'](); - noExitRuntime = true; - var destinationDirectory = PATH.dirname(_file); - FS.createPreloadedFile( - destinationDirectory, - PATH.basename(_file), - _url, true, true, - _emscripten_async_resume, - _emscripten_async_resume, - undefined, // dontCreateFile - undefined, // canOwn - function() { // preFinish - // if the destination directory does not yet exist, create it - FS.mkdirTree(destinationDirectory); - } - ); - }, - - emscripten_fiber_init: function() { - throw 'emscripten_fiber_init is not implemented for fastcomp ASYNCIFY'; - }, - emscripten_fiber_init_from_current_context: function() { - throw 'emscripten_fiber_init_from_current_context is not implemented for fastcomp ASYNCIFY'; - }, - emscripten_fiber_swap: function() { - throw 'emscripten_fiber_swap is not implemented for fastcomp ASYNCIFY'; - }, - -#else // !WASM_BACKEND $Asyncify__deps: ['$Browser', '$runAndAbortIfError'], $Asyncify: { State: { @@ -719,7 +497,6 @@ mergeInto(LibraryManager.library, { emscripten_yield: function() { throw 'emscripten_yield has been removed. Please use the Fibers API'; }, -#endif #else // ASYNCIFY emscripten_sleep: function() { throw 'Please compile your program with async support in order to use asynchronous operations like emscripten_sleep'; @@ -754,6 +531,6 @@ mergeInto(LibraryManager.library, { #endif // ASYNCIFY }); -if (WASM_BACKEND && ASYNCIFY) { +if (ASYNCIFY) { DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push('$Asyncify'); } diff --git a/src/library_idbstore.js b/src/library_idbstore.js index ce636b6990f71..d407710a7c3c2 100644 --- a/src/library_idbstore.js +++ b/src/library_idbstore.js @@ -55,7 +55,7 @@ var LibraryIDBStore = { }); }, -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY emscripten_idb_load: function(db, id, pbuffer, pnum, perror) { Asyncify.handleSleep(function(wakeUp) { IDBStore.getFile(UTF8ToString(db), UTF8ToString(id), function(error, byteArray) { @@ -166,7 +166,7 @@ var LibraryIDBStore = { emscripten_idb_exists: function() { throw 'Please compile your program with async support in order to use synchronous operations like emscripten_idb_exists, etc.'; }, -#endif // WASM_BACKEND && ASYNCIFY +#endif // ASYNCIFY }; autoAddDeps(LibraryIDBStore, '$IDBStore'); diff --git a/src/library_sdl.js b/src/library_sdl.js index 5219431e46b4d..46edd2d9ae102 100644 --- a/src/library_sdl.js +++ b/src/library_sdl.js @@ -1730,7 +1730,7 @@ var LibrarySDL = { // We actually do the whole screen in Unlock... }, -#if !(WASM_BACKEND && ASYNCIFY) +#if !ASYNCIFY SDL_Delay: function(delay) { if (!ENVIRONMENT_IS_WORKER) abort('SDL_Delay called on the main thread! Potential infinite loop, quitting. (consider building with async support like ASYNCIFY)'); // horrible busy-wait, but in a worker it at least does not block rendering @@ -2504,7 +2504,7 @@ var LibrarySDL = { } } -#if (ASYNCIFY && WASM_BACKEND) +#if ASYNCIFY var sleepCallback = function() { if (SDL.audio && SDL.audio.queueNewAudioData) SDL.audio.queueNewAudioData(); }; diff --git a/src/library_syscall.js b/src/library_syscall.js index d9c558bc511f9..d0d79be4db765 100644 --- a/src/library_syscall.js +++ b/src/library_syscall.js @@ -1565,7 +1565,7 @@ var SyscallsLibrary = { fd_sync__sig: 'ii', fd_sync: function(fd) { var stream = SYSCALLS.getStreamFromFD(fd); -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY return Asyncify.handleSleep(function(wakeUp) { var mount = stream.node.mount; if (!mount.type.syncfs) { @@ -1586,7 +1586,7 @@ var SyscallsLibrary = { return -stream.stream_ops.fsync(stream); } return 0; // we can't do anything synchronously; the in-memory FS is already synced to -#endif // WASM_BACKEND && ASYNCIFY +#endif // ASYNCIFY }, #if !WASM_BACKEND diff --git a/src/postamble.js b/src/postamble.js index 503160e69e79c..c9d49b4f80e7a 100644 --- a/src/postamble.js +++ b/src/postamble.js @@ -220,16 +220,16 @@ function callMain(args) { // In PROXY_TO_PTHREAD builds, we should never exit the runtime below, as execution is asynchronously handed // off to a pthread. #if !PROXY_TO_PTHREAD -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY // if we are saving the stack, then do not call exit, we are not // really exiting now, just unwinding the JS stack if (!noExitRuntime) { -#endif // WASM_BACKEND && ASYNCIFY +#endif // ASYNCIFY // if we're not running an evented main loop, it's time to exit exit(ret, /* implicit = */ true); -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY } -#endif // WASM_BACKEND && ASYNCIFY +#endif // ASYNCIFY } catch(e) { if (e instanceof ExitStatus) { diff --git a/src/preamble.js b/src/preamble.js index 2c1afefc65bf4..2209edef6a74a 100644 --- a/src/preamble.js +++ b/src/preamble.js @@ -137,7 +137,7 @@ function ccall(ident, returnType, argTypes, args, opts) { } } var ret = func.apply(null, cArgs); -#if ASYNCIFY && WASM_BACKEND +#if ASYNCIFY var asyncMode = opts && opts.async; var runningAsync = typeof Asyncify === 'object' && Asyncify.currData; var prevRunningAsync = typeof Asyncify === 'object' && Asyncify.asyncFinalizers.length > 0; @@ -163,7 +163,7 @@ function ccall(ident, returnType, argTypes, args, opts) { ret = convertReturnValue(ret); if (stack !== 0) stackRestore(stack); -#if ASYNCIFY && WASM_BACKEND +#if ASYNCIFY // If this is an async ccall, ensure we return a promise if (opts && opts.async) return Promise.resolve(ret); #endif @@ -906,7 +906,7 @@ function createWasm() { #if RELOCATABLE exports = relocateExports(exports, GLOBAL_BASE, 0); #endif -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY exports = Asyncify.instrumentWasmExports(exports); #endif Module['asm'] = exports; @@ -1122,7 +1122,7 @@ function createWasm() { if (Module['instantiateWasm']) { try { var exports = Module['instantiateWasm'](info, receiveInstance); -#if WASM_BACKEND && ASYNCIFY +#if ASYNCIFY exports = Asyncify.instrumentWasmExports(exports); #endif return exports;