emnapi 0.34.0 → 0.35.0

package/CMakeLists.txt

@@ -1,6 +1,6 @@
 cmake_minimum_required(VERSION 3.13)
 
-project(emnapi)
+project(emnapi LANGUAGES C ASM)
 
 option(EMNAPI_INSTALL_SRC "EMNAPI_INSTALL_SRC" OFF)
 option(EMNAPI_FIND_NODE_ADDON_API "EMNAPI_FIND_NODE_ADDON_API" OFF)
@@ -50,10 +50,13 @@ else()
 endif()
 
 set(EMNAPI_BASIC_TARGET_NAME "emnapi-basic")
+set(EMNAPI_BASIC_MT_TARGET_NAME "emnapi-basic-mt")
 set(EMNAPI_TARGET_NAME "emnapi")
 set(EMNAPI_MT_TARGET_NAME "emnapi-mt")
 set(DLMALLOC_TARGET_NAME "dlmalloc")
+set(DLMALLOC_MT_TARGET_NAME "dlmalloc-mt")
 set(EMMALLOC_TARGET_NAME "emmalloc")
+set(EMMALLOC_MT_TARGET_NAME "emmalloc-mt")
 
 if(EMNAPI_FIND_NODE_ADDON_API)
   execute_process(
@@ -82,11 +85,26 @@ if(IS_WASM32)
     "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/dlmalloc/dlmalloc.c"
   )
   target_compile_definitions(${DLMALLOC_TARGET_NAME} PRIVATE "PAGESIZE=65536")
+
+  add_library(${DLMALLOC_MT_TARGET_NAME} STATIC
+    ${MALLOC_PUBLIC_SOURCES}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/dlmalloc/dlmalloc.c"
+  )
+  target_compile_options(${DLMALLOC_MT_TARGET_NAME} PUBLIC "-matomics" "-mbulk-memory")
+  target_compile_definitions(${DLMALLOC_MT_TARGET_NAME} PRIVATE "PAGESIZE=65536" "USE_LOCKS=1")
+
   add_library(${EMMALLOC_TARGET_NAME} STATIC
     ${MALLOC_PUBLIC_SOURCES}
     "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/emmalloc/emmalloc.c"
   )
   target_compile_definitions(${EMMALLOC_TARGET_NAME} PRIVATE "PAGESIZE=65536")
+
+  add_library(${EMMALLOC_MT_TARGET_NAME} STATIC
+    ${MALLOC_PUBLIC_SOURCES}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/malloc/emmalloc/emmalloc.c"
+  )
+  target_compile_options(${EMMALLOC_MT_TARGET_NAME} PUBLIC "-matomics" "-mbulk-memory")
+  target_compile_definitions(${EMMALLOC_MT_TARGET_NAME} PRIVATE "PAGESIZE=65536" "__EMSCRIPTEN_SHARED_MEMORY__=1")
 endif()
 
 add_library(${EMNAPI_TARGET_NAME} STATIC ${EMNAPI_SRC} ${UV_SRC})
@@ -101,6 +119,22 @@ if(IS_EMSCRIPTEN)
   target_link_options(${EMNAPI_BASIC_TARGET_NAME} INTERFACE "--js-library=${EMNAPI_JS_LIB}")
 endif()
 
+if(IS_WASM32 OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi") OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads"))
+  set(EMNAPI_BUILD_BASIC_MT ON)
+else()
+  set(EMNAPI_BUILD_BASIC_MT OFF)
+endif()
+
+if(EMNAPI_BUILD_BASIC_MT)
+  add_library(${EMNAPI_BASIC_MT_TARGET_NAME} STATIC
+    ${ENAPI_BASIC_SRC}
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_create.c"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/thread/async_worker_init.S"
+  )
+  target_compile_options(${EMNAPI_BASIC_MT_TARGET_NAME} PUBLIC "-matomics" "-mbulk-memory")
+  target_include_directories(${EMNAPI_BASIC_MT_TARGET_NAME} PUBLIC ${EMNAPI_INCLUDE})
+endif()
+
 if(IS_EMSCRIPTEN OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads"))
   set(EMNAPI_BUILD_MT ON)
 else()
@@ -141,9 +175,14 @@ if(LIB_ARCH)
   if(EMNAPI_BUILD_MT)
     install(TARGETS ${EMNAPI_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   endif()
+  if(EMNAPI_BUILD_BASIC_MT)
+    install(TARGETS ${EMNAPI_BASIC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+  endif()
   if(IS_WASM32)
     install(TARGETS ${DLMALLOC_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+    install(TARGETS ${DLMALLOC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
     install(TARGETS ${EMMALLOC_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
+    install(TARGETS ${EMMALLOC_MT_TARGET_NAME} DESTINATION "lib/${LIB_ARCH}")
   endif()
 endif()
 
@@ -178,4 +217,7 @@ if(EMNAPI_INSTALL_SRC)
   install(DIRECTORY
     ${CMAKE_CURRENT_SOURCE_DIR}/src/malloc
     DESTINATION "src/${PROJECT_NAME}")
+  install(DIRECTORY
+    ${CMAKE_CURRENT_SOURCE_DIR}/src/thread
+    DESTINATION "src/${PROJECT_NAME}")
 endif()

package/README.md

@@ -6,7 +6,7 @@
 
 [![Build](https://github.com/toyobayashi/emnapi/actions/workflows/main.yml/badge.svg?branch=main)](https://github.com/toyobayashi/emnapi/actions/workflows/main.yml)
 
-[Node-API](https://nodejs.org/docs/latest/api/n-api.html) implementation for [Emscripten](https://emscripten.org/index.html), [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) and clang with wasm support. [napi-rs support is comming soon](https://github.com/napi-rs/napi-rs/tree/emnapi).
+[Node-API](https://nodejs.org/docs/latest/api/n-api.html) implementation for [Emscripten](https://emscripten.org/index.html), [wasi-sdk](https://github.com/WebAssembly/wasi-sdk) and clang with wasm support. napi-rs support is comming soon.
 
 This project aims to
 
@@ -25,16 +25,6 @@ See documentation for more details:
 
 [How to build Node-API official examples](https://github.com/toyobayashi/node-addon-examples)
 
-Emscripten is the first class support target. If your target is running addon on browser,
-we strongly recommend you to use Emscripten instead of wasi-sdk. Async works and threadsafe
-functions related APIs are only available on Emscripten or `wasm32-wasi-threads` target since
-they are relying on pthread. Though today we have [WASI browser polyfill](https://github.com/toyobayashi/wasm-util),
-`wasm32-wasi-threads` is in very early stage and WASI itself is not designed for browser.
-There are some limitations on browser about wasi-libc's pthread implementation, for example
-`pthread_mutex_lock` may call `__builtin_wasm_memory_atomic_wait32`(`memory.atomic.wait32`)
-which is disallowed in browser JS main thread. While Emscripten's pthread implementation
-has considered usage in browser.
-
 ## Prerequests
 
 You will need to install:
@@ -275,6 +265,9 @@ declare namespace Module {
      * napi_create_async_work and napi_create_threadsafe_function
      */
     nodeBinding?: typeof import('@emnapi/node-binding')
+
+    /** See Multithread part */
+    asyncWorkPoolSize?: number
   }
   export function emnapiInit (options: EmnapiInitOptions): any
 }
@@ -732,20 +725,60 @@ pub unsafe extern "C" fn napi_register_wasm_v1(env: napi_env, exports: napi_valu
 
 ### Multithread
 
-If you want to use async work or thread safe functions,
-there are additional C source file need to be compiled and linking.
-Recommend use CMake directly.
+Related API:
+
+- [napi_*_async_work](https://nodejs.org/dist/latest/docs/api/n-api.html#napi_create_async_work)
+- [napi_*_threadsafe_function](https://nodejs.org/dist/latest/docs/api/n-api.html#asynchronous-thread-safe-function-calls)
+
+They are available in emnapi, but you need to know more details before you start to use them.
+Now emnapi has 3 implementations of async work and 2 implementations of TSFN:
+
+- Async work
+    - A. Libuv threadpool and pthread based implementation in C
+    - B. Single thread mock in JavaScript
+    - C. Web worker based implementation in C (stack allocation) and JavaScript
+- TSFN
+    - D. Libuv and pthread based implementation in C
+    - E. Web worker based implementation in JavaScript
+
+|   | Library to Link        | `wasm32-emscripten` | `wasm32` | `wasm32-wasi` | `wasm32-wasi-threads` |
+|---|------------------------|---------------------|----------|---------------|-----------------------|
+| A | libemnapi-mt.a         | ✅                   | ❌        | ❌             | ✅                     |
+| B | libemnapi-basic(-mt).a | ✅                   | ✅        | ✅             | ✅                     |
+| C | libemnapi-basic-mt.a   | ❌                   | ✅        | ❌             | ✅                     |
+| D | libemnapi-mt.a         | ✅                   | ❌        | ❌             | ✅                     |
+| E | libemnapi-basic-mt.a   | ✅                   | ✅        | ✅             | ✅                     |
 
-**This is EXPERIMENTAL on non-emscripten.**
+There are some limitations on browser about wasi-libc's pthread implementation, for example
+`pthread_mutex_lock` may call `__builtin_wasm_memory_atomic_wait32`(`memory.atomic.wait32`)
+which is disallowed in browser JS main thread. While Emscripten's pthread implementation
+has considered usage in browser. If you need to run your addon with multithreaded features on browser,
+we recommend you use Emscripten A & D, or bare wasm32 C & E.
+
+#### About Prebuilt Libraries
+
+Prebuilt libraries can be found in the `lib` directory in `emnapi` npm package.
+
+| Library              | Description                                                                                                                                                                                                                                                   | `wasm32-emscripten` | `wasm32` | `wasm32-wasi` | `wasm32-wasi-threads`                   |
+|----------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------|----------|---------------|-----------------------------------------|
+| libemnapi.a          | no atomics feature.<br/><br/> no libuv port.<br/><br/> `napi_*_async_work` and `napi_*_threadsafe_function` always return `napi_generic_failure`.                                                                                                                         | ✅                   | ✅        | ✅             | waiting wasi-sdk release thread support |
+| libemnapi-mt.a       | atomics feature enabled.<br/><br/> `napi_*_async_work` and `napi_*_threadsafe_function` are based on pthread and libuv port.                                                                                                                                        | ✅                   | ❌        | ❌             | waiting wasi-sdk release thread support |
+| libemnapi-basic.a    | no atomics feature.<br/><br/> no libuv port.<br/><br/> `napi_*_async_work` and `napi_*_threadsafe_function` are imported from JavaScript land.                                                                                                                            | ✅                   | ✅        | ✅             | waiting wasi-sdk release thread support |
+| libemnapi-basic-mt.a | atomics feature enabled.<br/><br/> no libuv port.<br/><br/> `napi_*_async_work` and `napi_*_threadsafe_function` are imported from JavaScript land.<br/><br/> include `emnapi_async_worker_create` and `emnapi_async_worker_init` for WebWorker based async work implementation. | ❌                   | ✅        | ✅             | waiting wasi-sdk release thread support |
+| libdlmalloc.a        | no atomics feature, no thread safe garanteed.                                                                                                                                                                                                                 | ❌                   | ✅        | ❌             | ❌                                       |
+| libdlmalloc-mt.a     | atomics feature enabled, thread safe.                                                                                                                                                                                                                         | ❌                   | ✅        | ❌             | ❌                                       |
+| libemmalloc.a        | no atomics feature, no thread safe garanteed.                                                                                                                                                                                                                 | ❌                   | ✅        | ❌             | ❌                                       |
+| libemmalloc-mt.a     | atomics feature enabled, thread safe.                                                                                                                                                                                                                         | ❌                   | ✅        | ❌             | ❌                                       |
+
+#### Usage
 
 ```cmake
 add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/node_modules/emnapi")
 
 add_executable(hello hello.c)
 
-target_link_libraries(hello emnapi-mt)
-
 if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
+  target_link_libraries(hello emnapi-mt)
   target_compile_options(hello PRIVATE "-pthread")
   target_link_options(hello PRIVATE
     "-sALLOW_MEMORY_GROWTH=1"
@@ -758,6 +791,7 @@ if(CMAKE_SYSTEM_NAME STREQUAL "Emscripten")
   )
 elseif(CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads")
   # Experimental
+  target_link_libraries(hello emnapi-mt)
   set_target_properties(hello PROPERTIES SUFFIX ".wasm")
   target_compile_options(hello PRIVATE "-fno-exceptions" "-pthread")
   target_link_options(hello PRIVATE
@@ -771,6 +805,19 @@ elseif(CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-wasi-threads")
     "-Wl,--import-undefined"
     "-Wl,--export-table"
   )
+elseif((CMAKE_C_COMPILER_TARGET STREQUAL "wasm32") OR (CMAKE_C_COMPILER_TARGET STREQUAL "wasm32-unknown-unknown"))
+  target_link_libraries(hello emnapi-basic-mt)
+  set_target_properties(hello PROPERTIES SUFFIX ".wasm")
+  target_compile_options(hello PRIVATE "-fno-exceptions" "-matomics" "-mbulk-memory")
+  target_link_options(hello PRIVATE
+    "-nostdlib"
+    "-Wl,--no-entry"
+    "-Wl,--export=napi_register_wasm_v1"
+    "-Wl,--export=emnapi_async_worker_create"
+    "-Wl,--export=emnapi_async_worker_init"
+    "-Wl,--import-memory,--shared-memory,--max-memory=2147483648,--import-undefined"
+    "-Wl,--export-dynamic,--export=malloc,--export=free,--export-table"
+  )
 endif()
 ```
 
@@ -784,6 +831,11 @@ cmake -DCMAKE_TOOLCHAIN_FILE=$WASI_SDK_PATH/share/cmake/wasi-sdk-pthread.cmake \
       -DCMAKE_BUILD_TYPE=Release \
       -G Ninja -H. -Bbuild
 
+cmake -DCMAKE_TOOLCHAIN_FILE=node_modules/emnapi/cmake/wasm32.cmake \
+      -DWASI_SDK_PREFIX=$WASI_SDK_PATH \
+      -DCMAKE_BUILD_TYPE=Release \
+      -G Ninja -H. -Bbuild
+
 cmake --build build
 ```
 
@@ -793,6 +845,15 @@ And additional work is required during instantiating wasm compiled with non-emsc
 // emnapi main thread (could be in a Worker)
 instantiateNapiModule(input, {
   context: getDefaultContext(),
+  /**
+   * emscripten
+   *   0: no effect
+   *   > 0: the same effect to UV_THREADPOOL_SIZE
+   * non-emscripten
+   *   0: single thread mock
+   *   > 0 schedule async work in web worker
+   */
+  asyncWorkPoolSize: 4, // 0: single thread mock, > 0: schedule async work in web worker
   wasi: new WASI(/* ... */),
   // reuseWorker: true,
   onCreateWorker () {
@@ -890,17 +951,30 @@ instantiateNapiModule(input, {
 
 ### `-DEMNAPI_WORKER_POOL_SIZE=4`
 
-This is [`UV_THREADPOOL_SIZE`](http://docs.libuv.org/en/v1.x/threadpool.html?highlight=UV_THREADPOOL_SIZE) equivalent at compile time, if not predefined, emnapi will read `UV_THREADPOOL_SIZE` from Emscripten [environment variable](https://emscripten.org/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html#interacting-with-code-environment-variables) at runtime, you can set `UV_THREADPOOL_SIZE` like this:
+This is [`UV_THREADPOOL_SIZE`](http://docs.libuv.org/en/v1.x/threadpool.html?highlight=UV_THREADPOOL_SIZE) equivalent at compile time, if not predefined, emnapi will read `asyncWorkPoolSize` option or `UV_THREADPOOL_SIZE` from Emscripten [environment variable](https://emscripten.org/docs/porting/connecting_cpp_and_javascript/Interacting-with-code.html#interacting-with-code-environment-variables) at runtime:
 
 ```js
+Module.init({
+  // ...
+  asyncWorkPoolSize: 2
+})
+
+// if asyncWorkPoolSize is not specified
 Module.preRun = Module.preRun || [];
 Module.preRun.push(function () {
   if (typeof ENV !== 'undefined') {
     ENV.UV_THREADPOOL_SIZE = '2';
   }
 });
+```
 
+```js
 // wasi
+instantiateNapiModule({
+  // ...
+  asyncWorkPoolSize: 2
+})
+// if asyncWorkPoolSize is not specified
 new WASI({
   env: {
     UV_THREADPOOL_SIZE: '2'
@@ -908,7 +982,7 @@ new WASI({
 })
 ```
 
-It represent max of `EMNAPI_WORKER_POOL_SIZE` async work (`napi_queue_async_work`) can be executed in parallel. Default is not defined, read `UV_THREADPOOL_SIZE` at runtime.
+It represent max of `EMNAPI_WORKER_POOL_SIZE` async work (`napi_queue_async_work`) can be executed in parallel. Default is not defined.
 
 You can set both `PTHREAD_POOL_SIZE` and `EMNAPI_WORKER_POOL_SIZE` to `number of CPU cores` in general.
 If you use another library function which may create `N` child threads in async work,

package/dist/library_napi.js

@@ -1,37 +1,33 @@
 {{{ ((DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.indexOf("$emnapiInit") === -1 ? DEFAULT_LIBRARY_FUNCS_TO_INCLUDE.push("$emnapiInit") : undefined), "") }}}
 {{{ ((EXPORTED_RUNTIME_METHODS.indexOf("emnapiInit") === -1 ? EXPORTED_RUNTIME_METHODS.push("emnapiInit") : undefined), "") }}}
-// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
-function emnapiCreateIdGenerator() {
-    var obj = {
-        nextId: 1,
-        list: [],
-        generate: function () {
-            var id;
-            if (obj.list.length) {
-                id = obj.list.shift();
-            }
-            else {
-                id = obj.nextId;
-                obj.nextId++;
-            }
-            return id;
-        },
-        reuse: function (id) {
-            obj.list.push(id);
-        }
-    };
-    return obj;
-}
-var emnapiAsyncWork = {
+var emnapiAWST = {
     idGen: {},
     values: [undefined],
     queued: new Set(),
     pending: [],
     init: function () {
-        emnapiAsyncWork.idGen = emnapiCreateIdGenerator();
-        emnapiAsyncWork.values = [undefined];
-        emnapiAsyncWork.queued = new Set();
-        emnapiAsyncWork.pending = [];
+        var idGen = {
+            nextId: 1,
+            list: [],
+            generate: function () {
+                var id;
+                if (idGen.list.length) {
+                    id = idGen.list.shift();
+                }
+                else {
+                    id = idGen.nextId;
+                    idGen.nextId++;
+                }
+                return id;
+            },
+            reuse: function (id) {
+                idGen.list.push(id);
+            }
+        };
+        emnapiAWST.idGen = idGen;
+        emnapiAWST.values = [undefined];
+        emnapiAWST.queued = new Set();
+        emnapiAWST.pending = [];
     },
     create: function (env, resource, resourceName, execute, complete, data) {
         var asyncId = 0;
@@ -41,12 +37,11 @@ var emnapiAsyncWork = {
             asyncId = asyncContext.asyncId;
             triggerAsyncId = asyncContext.triggerAsyncId;
         }
-        var id = emnapiAsyncWork.idGen.generate();
-        emnapiAsyncWork.values[id] = {
+        var id = emnapiAWST.idGen.generate();
+        emnapiAWST.values[id] = {
             env: env,
             id: id,
             resource: resource,
-            resourceName: resourceName,
             asyncId: asyncId,
             triggerAsyncId: triggerAsyncId,
             status: 0,
@@ -62,6 +57,8 @@ var emnapiAsyncWork = {
         var env = work.env;
         var data = work.data;
         var callback = function () {
+            if (!complete)
+                return;
             var envObject = emnapiCtx.envStore.get(env);
             var scope = emnapiCtx.openScope(envObject);
             try {
@@ -84,16 +81,16 @@ var emnapiAsyncWork = {
         }
     },
     queue: function (id) {
-        var work = emnapiAsyncWork.values[id];
+        var work = emnapiAWST.values[id];
         if (!work)
             return;
         if (work.status === 0) {
             work.status = 1;
-            if (emnapiAsyncWork.queued.size >= 4) {
-                emnapiAsyncWork.pending.push(id);
+            if (emnapiAWST.queued.size >= (Math.abs(emnapiAsyncWorkPoolSize) || 4)) {
+                emnapiAWST.pending.push(id);
                 return;
             }
-            emnapiAsyncWork.queued.add(id);
+            emnapiAWST.queued.add(id);
             var env_1 = work.env;
             var data_1 = work.data;
             // eslint-disable-next-line @typescript-eslint/no-unused-vars
@@ -101,25 +98,29 @@ var emnapiAsyncWork = {
             work.status = 2;
             emnapiCtx.feature.setImmediate(function () {
                 {{{ makeDynCall('vpp', 'execute') }}}(env_1, data_1);
-                emnapiAsyncWork.queued.delete(id);
+                emnapiAWST.queued.delete(id);
                 work.status = 3;
-                emnapiAsyncWork.callComplete(work, 0 /* napi_status.napi_ok */);
-                if (emnapiAsyncWork.pending.length > 0) {
-                    var nextWorkId = emnapiAsyncWork.pending.shift();
-                    emnapiAsyncWork.values[nextWorkId].status = 0;
-                    emnapiAsyncWork.queue(nextWorkId);
+                emnapiCtx.feature.setImmediate(function () {
+                    emnapiAWST.callComplete(work, 0 /* napi_status.napi_ok */);
+                });
+                if (emnapiAWST.pending.length > 0) {
+                    var nextWorkId = emnapiAWST.pending.shift();
+                    emnapiAWST.values[nextWorkId].status = 0;
+                    emnapiAWST.queue(nextWorkId);
                 }
             });
         }
     },
     cancel: function (id) {
-        var index = emnapiAsyncWork.pending.indexOf(id);
+        var index = emnapiAWST.pending.indexOf(id);
         if (index !== -1) {
-            var work = emnapiAsyncWork.values[id];
-            if (work && (work.status === 1)) {
-                work.status = 4;
-                emnapiAsyncWork.pending.splice(index, 1);
-                emnapiAsyncWork.callComplete(work, 11 /* napi_status.napi_cancelled */);
+            var work_1 = emnapiAWST.values[id];
+            if (work_1 && (work_1.status === 1)) {
+                work_1.status = 4;
+                emnapiAWST.pending.splice(index, 1);
+                emnapiCtx.feature.setImmediate(function () {
+                    emnapiAWST.callComplete(work_1, 11 /* napi_status.napi_cancelled */);
+                });
                 return 0 /* napi_status.napi_ok */;
             }
             else {
@@ -129,7 +130,7 @@ var emnapiAsyncWork = {
         return 9 /* napi_status.napi_generic_failure */;
     },
     remove: function (id) {
-        var work = emnapiAsyncWork.values[id];
+        var work = emnapiAWST.values[id];
         if (!work)
             return;
         if (emnapiNodeBinding) {
@@ -138,68 +139,11 @@ var emnapiAsyncWork = {
                 triggerAsyncId: work.triggerAsyncId
             });
         }
-        emnapiAsyncWork.values[id] = undefined;
-        emnapiAsyncWork.idGen.reuse(id);
+        emnapiAWST.values[id] = undefined;
+        emnapiAWST.idGen.reuse(id);
     }
 };
-function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (execute == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    if (result == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var resourceObject;
-    if (resource) {
-        resourceObject = Object(emnapiCtx.handleStore.get(resource).value);
-    }
-    else {
-        resourceObject = {};
-    }
-    if (resource_name == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    var id = emnapiAsyncWork.create(env, resourceObject, resourceName, execute, complete, data);
-    {{{ makeSetValue('result', 0, 'id', '*') }}};
-    return envObject.clearLastError();
-}
-function _napi_delete_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    emnapiAsyncWork.remove(work);
-    return envObject.clearLastError();
-}
-function _napi_queue_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    emnapiAsyncWork.queue(work);
-    return envObject.clearLastError();
-}
-function _napi_cancel_async_work(env, work) {
-    if (env == 0)
-        return 1 /* napi_status.napi_invalid_arg */;
-    var envObject = emnapiCtx.envStore.get(env);
-    if (work == 0)
-        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
-    var status = emnapiAsyncWork.cancel(work);
-    if (status === 0 /* napi_status.napi_ok */)
-        return envObject.clearLastError();
-    return envObject.setLastError(status);
-}
-emnapiImplementHelper('$emnapiCreateIdGenerator', undefined, emnapiCreateIdGenerator, []);
-emnapiDefineVar('$emnapiAsyncWork', emnapiAsyncWork, ['$emnapiCreateIdGenerator'], 'emnapiAsyncWork.init();');
-emnapiImplement('napi_create_async_work', 'ippppppp', _napi_create_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_delete_async_work', 'ipp', _napi_delete_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_queue_async_work', 'ipp', _napi_queue_async_work, ['$emnapiAsyncWork']);
-emnapiImplement('napi_cancel_async_work', 'ipp', _napi_cancel_async_work, ['$emnapiAsyncWork']);
+emnapiDefineVar('$emnapiAWST', emnapiAWST, ['$emnapiAsyncWorkPoolSize'], 'emnapiAWST.init();');
 function _emnapi_create_memory_view(env, typedarray_type, external_data, byte_length, finalize_cb, finalize_hint, result
 // @ts-expect-error
 ) {
@@ -5468,6 +5412,62 @@ emnapiImplement('napi_get_boolean', 'ipip', napi_get_boolean);
 emnapiImplement('napi_get_global', 'ipp', napi_get_global);
 emnapiImplement('napi_get_null', 'ipp', napi_get_null);
 emnapiImplement('napi_get_undefined', 'ipp', napi_get_undefined);
+function _napi_create_async_work(env, resource, resource_name, execute, complete, data, result) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (execute == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    if (result == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceObject;
+    if (resource) {
+        resourceObject = Object(emnapiCtx.handleStore.get(resource).value);
+    }
+    else {
+        resourceObject = {};
+    }
+    if (resource_name == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var resourceName = String(emnapiCtx.handleStore.get(resource_name).value);
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    var id = emnapiAWST.create(env, resourceObject, resourceName, execute, complete, data);
+    {{{ makeSetValue('result', 0, 'id', '*') }}};
+    return envObject.clearLastError();
+}
+function _napi_delete_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.remove(work);
+    return envObject.clearLastError();
+}
+function _napi_queue_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    emnapiAWST.queue(work);
+    return envObject.clearLastError();
+}
+function _napi_cancel_async_work(env, work) {
+    if (env == 0)
+        return 1 /* napi_status.napi_invalid_arg */;
+    var envObject = emnapiCtx.envStore.get(env);
+    if (work == 0)
+        return envObject.setLastError(1 /* napi_status.napi_invalid_arg */);
+    var status = emnapiAWST.cancel(work);
+    if (status === 0 /* napi_status.napi_ok */)
+        return envObject.clearLastError();
+    return envObject.setLastError(status);
+}
+emnapiImplement('napi_create_async_work', 'ippppppp', _napi_create_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_delete_async_work', 'ipp', _napi_delete_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_queue_async_work', 'ipp', _napi_queue_async_work, ['$emnapiAWST']);
+emnapiImplement('napi_cancel_async_work', 'ipp', _napi_cancel_async_work, ['$emnapiAWST']);
 mergeInto(LibraryManager.library, {
     _emnapi_worker_unref__sig: 'vp',
     _emnapi_worker_unref__deps: ['$PThread'],
@@ -5618,6 +5618,7 @@ emnapiDefineVar('$emnapiModule', {
     loaded: false,
     filename: ''
 });
+emnapiDefineVar('$emnapiAsyncWorkPoolSize', 0);
 function emnapiInit(options) {
     if (emnapiModule.loaded)
         return emnapiModule.exports;
@@ -5639,6 +5640,18 @@ function emnapiInit(options) {
         }
         emnapiNodeBinding = nodeBinding;
     }
+    if ('asyncWorkPoolSize' in options) {
+        if (typeof options.asyncWorkPoolSize !== 'number') {
+            throw new TypeError('options.asyncWorkPoolSize must be a integer');
+        }
+        emnapiAsyncWorkPoolSize = options.asyncWorkPoolSize >> 0;
+        if (emnapiAsyncWorkPoolSize > 1024) {
+            emnapiAsyncWorkPoolSize = 1024;
+        }
+        else if (emnapiAsyncWorkPoolSize < -1024) {
+            emnapiAsyncWorkPoolSize = -1024;
+        }
+    }
     // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
     var envObject = emnapiModule.envObject || (emnapiModule.envObject = emnapiCtx.createEnv(function (cb) { return {{{ makeDynCall('vppp', 'cb') }}}; }, function (cb) { return {{{ makeDynCall('vp', 'cb') }}}; }));
     var scope = emnapiCtx.openScope(envObject);
@@ -5660,7 +5673,11 @@ function emnapiInit(options) {
     delete emnapiModule.envObject;
     return emnapiModule.exports;
 }
-emnapiImplementHelper('$emnapiInit', undefined, emnapiInit, ['$emnapiModule', '$emnapiCtx', '$emnapiNodeBinding', 'napi_register_wasm_v1']);
+emnapiImplementHelper('$emnapiInit', undefined, emnapiInit, ['$emnapiModule', '$emnapiCtx', '$emnapiNodeBinding', '$emnapiAsyncWorkPoolSize', 'napi_register_wasm_v1']);
+function __emnapi_async_work_pool_size() {
+    return Math.abs(emnapiAsyncWorkPoolSize);
+}
+emnapiImplementInternal('_emnapi_async_work_pool_size', 'i', __emnapi_async_work_pool_size, ['$emnapiAsyncWorkPoolSize']);
 function __emnapi_get_filename(buf, len) {
     if (!buf) {
         return lengthBytesUTF8(emnapiModule.filename);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "emnapi",
-  "version": "0.34.0",
+  "version": "0.35.0",
   "description": "Node-API implementation for Emscripten",
   "main": "index.js",
   "devDependencies": {

package/src/thread/async_worker_create.c

@@ -0,0 +1,76 @@
+#include <stddef.h>
+#include <stdint.h>
+
+void* calloc(size_t n, size_t size);
+
+extern unsigned char __heap_base;
+extern unsigned char __data_end;
+extern unsigned char __global_base;
+extern __attribute__((__weak__)) unsigned char __stack_high;
+extern __attribute__((__weak__)) unsigned char __stack_low;
+
+#define ROUND_UP(x, ALIGNMENT) (((x)+ALIGNMENT-1)&-ALIGNMENT)
+#define STACK_ALIGN 16
+#define DEFAULT_STACK_MAX (8<<20)
+
+struct worker_args {
+  void* stack_base;
+  void* tls_base;
+};
+
+extern void __wasm_init_tls(void*);
+
+void* __copy_tls(unsigned char *mem) {
+	size_t tls_align = __builtin_wasm_tls_align();
+	volatile void* tls_base = __builtin_wasm_tls_base();
+	mem += tls_align;
+	mem -= (uintptr_t)mem & (tls_align-1);
+	__wasm_init_tls(mem);
+  	__asm__("local.get %0\n"
+			"global.set __tls_base\n"
+			:: "r"(tls_base));
+	return mem;
+}
+
+__attribute__((visibility("default")))
+void* emnapi_async_worker_create() {
+  size_t args_size = sizeof(struct worker_args);
+  size_t size = args_size;
+
+  size_t tls_size = __builtin_wasm_tls_size();
+
+  size_t tls_block_size = 0;
+  if (tls_size) {
+    size_t tls_align = __builtin_wasm_tls_align();
+    tls_block_size = ROUND_UP(tls_size + tls_align - 1, tls_align);
+    size += tls_block_size;
+  }
+
+  ptrdiff_t stack_size = 0;
+  if (&__stack_high) {
+		stack_size = &__stack_high - &__stack_low;
+  } else {
+		unsigned char *sp;
+		__asm__(
+			".globaltype __stack_pointer, i32\n"
+			"global.get __stack_pointer\n"
+			"local.set %0\n"
+			: "=r"(sp));
+		stack_size = sp > &__global_base ? &__heap_base - &__data_end : (ptrdiff_t)&__global_base;
+	}
+
+  stack_size = ROUND_UP(stack_size, STACK_ALIGN);
+  stack_size = stack_size < DEFAULT_STACK_MAX ? stack_size : DEFAULT_STACK_MAX;
+  size += stack_size;
+
+  void* block = calloc(1, size);
+  if (!block) return 0;
+
+  void* tls_base = tls_size ? __copy_tls(block + args_size) : 0;
+
+  struct worker_args* args = (struct worker_args*)block;
+
+  args->stack_base = block + args_size + tls_block_size + stack_size;
+  args->tls_base = tls_base;
+  return block;
+}

package/src/thread/async_worker_init.S

@@ -0,0 +1,33 @@
+#ifdef __wasm64__
+#define PTR i64
+#else
+#define PTR i32
+#endif
+
+  .text
+
+  .export_name  emnapi_async_worker_init, emnapi_async_worker_init
+
+  .globaltype  __stack_pointer, PTR
+  .globaltype  __tls_base, PTR
+
+  .hidden  emnapi_async_worker_init
+  .globl  emnapi_async_worker_init
+  .type  emnapi_async_worker_init,@function
+
+emnapi_async_worker_init:
+  .functype  emnapi_async_worker_init (PTR) -> ()
+
+  local.get   0
+  PTR.load    0
+  global.set  __stack_pointer
+
+  local.get   0
+#ifdef __wasm64__
+  PTR.load    8
+#else
+  PTR.load    4
+#endif
+  global.set  __tls_base
+
+  end_function

package/src/uv/threadpool.c

@@ -209,6 +209,7 @@ static void post(QUEUE* q, enum uv__work_kind kind) {
 //   nthreads = 0;
 // }
 
+EMNAPI_EXTERN int _emnapi_async_work_pool_size();
 
 static void init_threads(void) {
   unsigned int i;
@@ -223,9 +224,14 @@ static void init_threads(void) {
   nthreads = EMNAPI_WORKER_POOL_SIZE;
 #else
   nthreads = ARRAY_SIZE(default_threads);
-  val = getenv("UV_THREADPOOL_SIZE");
-  if (val != NULL)
-    nthreads = atoi(val);
+  int async_work_pool_size = _emnapi_async_work_pool_size();
+  if (async_work_pool_size > 0) {
+    nthreads = (unsigned int) async_work_pool_size;
+  } else {
+    val = getenv("UV_THREADPOOL_SIZE");
+    if (val != NULL)
+      nthreads = atoi(val);
+  }
 #endif
   if (nthreads == 0)
     nthreads = 1;