wasi: fast calls

Author: devsnek

src/node_wasi.cc

@@ -72,18 +72,28 @@ inline void Debug(WASI* wasi, Args&&... args) {
     }                                                                         \
   } while (0)
 
+#define CHECK_BOUNDS_OR_RETURN2(mem_size, offset, buf_size)                    \
+  do {                                                                         \
+    if (!uvwasi_serdes_check_bounds((offset), (mem_size), (buf_size))) {       \
+      return UVWASI_EOVERFLOW;                                                 \
+    }                                                                          \
+  } while (0)
+
 using v8::Array;
 using v8::BackingStore;
 using v8::BigInt;
+using v8::CFunction;
 using v8::Context;
 using v8::Exception;
+using v8::FastApiCallbackOptions;
 using v8::FunctionCallbackInfo;
 using v8::FunctionTemplate;
 using v8::Integer;
 using v8::Isolate;
 using v8::Local;
 using v8::MaybeLocal;
 using v8::Object;
+using v8::Signature;
 using v8::String;
 using v8::Uint32;
 using v8::Value;
@@ -248,46 +258,155 @@ void WASI::New(const FunctionCallbackInfo<Value>& args) {
   }
 }
 
+struct WasmMemory {
+  char* data;
+  size_t size;
+};
+
+template <auto F, typename R, typename... Args>
+class WasiFunction {
+ public:
+  static void SetFunction(Environment* env,
+                          const char* name,
+                          Local<FunctionTemplate> tmpl) {
+    auto c_function = CFunction::Make(FastCallback);
+    Local<FunctionTemplate> t =
+        v8::FunctionTemplate::New(env->isolate(),
+                                  SlowCallback,
+                                  Local<Value>(),
+                                  Local<Signature>(),
+                                  sizeof...(Args),
+                                  v8::ConstructorBehavior::kThrow,
+                                  v8::SideEffectType::kHasSideEffect,
+                                  &c_function);
+    const v8::NewStringType type = v8::NewStringType::kInternalized;
+    v8::Local<v8::String> name_string =
+        v8::String::NewFromUtf8(env->isolate(), name, type).ToLocalChecked();
+    tmpl->PrototypeTemplate()->Set(name_string, t);
+    t->SetClassName(name_string);
+  }
 
-void WASI::ArgsGet(const FunctionCallbackInfo<Value>& args) {
-  WASI* wasi;
-  uint32_t argv_offset;
-  uint32_t argv_buf_offset;
-  char* memory;
-  size_t mem_size;
-  RETURN_IF_BAD_ARG_COUNT(args, 2);
-  CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, argv_offset);
-  CHECK_TO_TYPE_OR_RETURN(args, args[1], Uint32, argv_buf_offset);
-  ASSIGN_INITIALIZED_OR_RETURN_UNWRAP(&wasi, args.This());
-  Debug(wasi, "args_get(%d, %d)\n", argv_offset, argv_buf_offset);
-  GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);
-  CHECK_BOUNDS_OR_RETURN(args,
-                         mem_size,
-                         argv_buf_offset,
-                         wasi->uvw_.argv_buf_size);
-  CHECK_BOUNDS_OR_RETURN(args,
-                         mem_size,
-                         argv_offset,
-                         wasi->uvw_.argc * UVWASI_SERDES_SIZE_uint32_t);
-  std::vector<char*> argv(wasi->uvw_.argc);
-  char* argv_buf = &memory[argv_buf_offset];
-  uvwasi_errno_t err = uvwasi_args_get(&wasi->uvw_, argv.data(), argv_buf);
+ private:
+  static R FastCallback(Local<Object> receiver,
+                        Args... args,
+                        FastApiCallbackOptions& options) {
+    WASI* wasi = reinterpret_cast<WASI*>(BaseObject::FromJSObject(receiver));
+    if (UNLIKELY(wasi == nullptr)) return UVWASI_EINVAL;
+
+    if (UNLIKELY(options.wasm_memory == nullptr)) return UVWASI_EINVAL;
+    uint8_t* memory = nullptr;
+    CHECK(LIKELY(options.wasm_memory->getStorageIfAligned(&memory)));
+
+    return F(*wasi, {(char*)memory, options.wasm_memory->length()}, args...);
+  }
+
+  template <typename VT>
+  static uvwasi_errno_t CheckType(Local<Value> v);
+
+  template <typename VT>
+  static VT ConvertType(Local<Value> V);
+
+  template <>
+  static uvwasi_errno_t CheckType<uint32_t>(Local<Value> value) {
+    if (!value->IsUint32()) return UVWASI_EINVAL;
+    return UVWASI_ESUCCESS;
+  }
+
+  template <>
+  static uint32_t ConvertType(Local<Value> value) {
+    return value.As<Uint32>()->Value();
+  }
+
+  template <>
+  static uvwasi_errno_t CheckType<uint64_t>(Local<Value> value) {
+    if (!value->IsBigInt()) return UVWASI_EINVAL;
+    return UVWASI_ESUCCESS;
+  }
+
+  template <>
+  static uint64_t ConvertType(Local<Value> value) {
+    Local<BigInt> js_value = value.As<BigInt>();
+    bool lossless;
+    return js_value->Uint64Value(&lossless);
+  }
+
+  template <>
+  static uvwasi_errno_t CheckType<int64_t>(Local<Value> value) {
+    if (!value->IsBigInt()) return UVWASI_EINVAL;
+    return UVWASI_ESUCCESS;
+  }
+
+  template <>
+  static int64_t ConvertType(Local<Value> value) {
+    Local<BigInt> js_value = value.As<BigInt>();
+    bool lossless;
+    return js_value->Int64Value(&lossless);
+  }
+
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wunsequenced"
+  static void SlowCallback(const FunctionCallbackInfo<Value>& args) {
+    WASI* wasi;
+    char* memory;
+    size_t mem_size;
+    RETURN_IF_BAD_ARG_COUNT(args, sizeof...(Args));
+    {
+      int counter = 0;
+      uvwasi_errno_t results[sizeof...(Args)] = {
+          (CheckType<Args>(args[counter++]))...};
+      for (size_t i = 0; i < sizeof...(Args); i += 1) {
+        if (results[i] != UVWASI_ESUCCESS) {
+          args.GetReturnValue().Set(results[i]);
+          return;
+        }
+      }
+    }
+    ASSIGN_INITIALIZED_OR_RETURN_UNWRAP(&wasi, args.This());
+    GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);
+
+    {
+      int counter = 0;
+      args.GetReturnValue().Set(
+          F(*wasi, {memory, mem_size}, ConvertType<Args>(args[counter++])...));
+    }
+  }
+#pragma clang diagnostic pop
+};
+
+template <auto F, typename R, typename... Args>
+static void SetFunction(R (*)(WASI&, WasmMemory, Args...),
+                        Environment* env,
+                        const char* name,
+                        Local<FunctionTemplate> tmpl) {
+  WasiFunction<F, R, Args...>::SetFunction(env, name, tmpl);
+}
+
+static uint32_t ArgsGet(WASI& wasi,
+                        WasmMemory memory,
+                        uint32_t argv_offset,
+                        uint32_t argv_buf_offset) {
+  Debug(&wasi, "args_get(%d, %d)\n", argv_offset, argv_buf_offset);
+
+  CHECK_BOUNDS_OR_RETURN2(
+      memory.size, argv_buf_offset, wasi.uvw_.argv_buf_size);
+  CHECK_BOUNDS_OR_RETURN2(
+      memory.size, argv_offset, wasi.uvw_.argc * UVWASI_SERDES_SIZE_uint32_t);
+  std::vector<char*> argv(wasi.uvw_.argc);
+  char* argv_buf = &memory.data[argv_buf_offset];
+  uvwasi_errno_t err = uvwasi_args_get(&wasi.uvw_, argv.data(), argv_buf);
 
   if (err == UVWASI_ESUCCESS) {
-    for (size_t i = 0; i < wasi->uvw_.argc; i++) {
+    for (size_t i = 0; i < wasi.uvw_.argc; i++) {
       uint32_t offset =
           static_cast<uint32_t>(argv_buf_offset + (argv[i] - argv[0]));
-      uvwasi_serdes_write_uint32_t(memory,
-                                   argv_offset +
-                                   (i * UVWASI_SERDES_SIZE_uint32_t),
-                                   offset);
+      uvwasi_serdes_write_uint32_t(
+          memory.data, argv_offset + (i * UVWASI_SERDES_SIZE_uint32_t), offset);
     }
   }
 
-  args.GetReturnValue().Set(err);
+  return err;
 }
 
-
 void WASI::ArgsSizesGet(const FunctionCallbackInfo<Value>& args) {
   WASI* wasi;
   uint32_t argc_offset;
@@ -454,25 +573,16 @@ void WASI::EnvironSizesGet(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
-
-void WASI::FdAdvise(const FunctionCallbackInfo<Value>& args) {
-  WASI* wasi;
-  uint32_t fd;
-  uint64_t offset;
-  uint64_t len;
-  uint8_t advice;
-  RETURN_IF_BAD_ARG_COUNT(args, 4);
-  CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);
-  UNWRAP_BIGINT_OR_RETURN(args, args[1], Uint64, offset);
-  UNWRAP_BIGINT_OR_RETURN(args, args[2], Uint64, len);
-  CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, advice);
-  ASSIGN_INITIALIZED_OR_RETURN_UNWRAP(&wasi, args.This());
-  Debug(wasi, "fd_advise(%d, %d, %d, %d)\n", fd, offset, len, advice);
-  uvwasi_errno_t err = uvwasi_fd_advise(&wasi->uvw_, fd, offset, len, advice);
-  args.GetReturnValue().Set(err);
+static uint32_t FdAdvise(WASI& wasi,
+                         WasmMemory,
+                         uint32_t fd,
+                         uint64_t offset,
+                         uint64_t len,
+                         uint32_t advice) {
+  Debug(&wasi, "fd_advise(%d, %d, %d, %d)\n", fd, offset, len, advice);
+  return uvwasi_fd_advise(&wasi.uvw_, fd, offset, len, advice);
 }
 
-
 void WASI::FdAllocate(const FunctionCallbackInfo<Value>& args) {
   WASI* wasi;
   uint32_t fd;
@@ -892,40 +1002,24 @@ void WASI::FdRenumber(const FunctionCallbackInfo<Value>& args) {
   args.GetReturnValue().Set(err);
 }
 
-
-void WASI::FdSeek(const FunctionCallbackInfo<Value>& args) {
-  WASI* wasi;
-  uint32_t fd;
-  int64_t offset;
-  uint8_t whence;
-  uint32_t newoffset_ptr;
-  char* memory;
-  size_t mem_size;
-  RETURN_IF_BAD_ARG_COUNT(args, 4);
-  CHECK_TO_TYPE_OR_RETURN(args, args[0], Uint32, fd);
-  UNWRAP_BIGINT_OR_RETURN(args, args[1], Int64, offset);
-  CHECK_TO_TYPE_OR_RETURN(args, args[2], Uint32, whence);
-  CHECK_TO_TYPE_OR_RETURN(args, args[3], Uint32, newoffset_ptr);
-  ASSIGN_INITIALIZED_OR_RETURN_UNWRAP(&wasi, args.This());
-  Debug(wasi, "fd_seek(%d, %d, %d, %d)\n", fd, offset, whence, newoffset_ptr);
-  GET_BACKING_STORE_OR_RETURN(wasi, args, &memory, &mem_size);
-  CHECK_BOUNDS_OR_RETURN(args,
-                         mem_size,
-                         newoffset_ptr,
-                         UVWASI_SERDES_SIZE_filesize_t);
+uint32_t FdSeek(WASI& wasi,
+                WasmMemory memory,
+                uint32_t fd,
+                int64_t offset,
+                uint32_t whence,
+                uint32_t newoffset_ptr) {
+  Debug(&wasi, "fd_seek(%d, %d, %d, %d)\n", fd, offset, whence, newoffset_ptr);
+  CHECK_BOUNDS_OR_RETURN2(
+      memory.size, newoffset_ptr, UVWASI_SERDES_SIZE_filesize_t);
   uvwasi_filesize_t newoffset;
-  uvwasi_errno_t err = uvwasi_fd_seek(&wasi->uvw_,
-                                      fd,
-                                      offset,
-                                      whence,
-                                      &newoffset);
+  uvwasi_errno_t err =
+      uvwasi_fd_seek(&wasi.uvw_, fd, offset, whence, &newoffset);
   if (err == UVWASI_ESUCCESS)
-    uvwasi_serdes_write_filesize_t(memory, newoffset_ptr, newoffset);
+    uvwasi_serdes_write_filesize_t(memory.data, newoffset_ptr, newoffset);
 
-  args.GetReturnValue().Set(err);
+  return err;
 }
 
-
 void WASI::FdSync(const FunctionCallbackInfo<Value>& args) {
   WASI* wasi;
   uint32_t fd;
@@ -1673,13 +1767,14 @@ static void Initialize(Local<Object> target,
   tmpl->InstanceTemplate()->SetInternalFieldCount(WASI::kInternalFieldCount);
   tmpl->Inherit(BaseObject::GetConstructorTemplate(env));
 
-  env->SetProtoMethod(tmpl, "args_get", WASI::ArgsGet);
+  SetFunction<ArgsGet>(ArgsGet, env, "args_get", tmpl);
+
   env->SetProtoMethod(tmpl, "args_sizes_get", WASI::ArgsSizesGet);
   env->SetProtoMethod(tmpl, "clock_res_get", WASI::ClockResGet);
   env->SetProtoMethod(tmpl, "clock_time_get", WASI::ClockTimeGet);
   env->SetProtoMethod(tmpl, "environ_get", WASI::EnvironGet);
   env->SetProtoMethod(tmpl, "environ_sizes_get", WASI::EnvironSizesGet);
-  env->SetProtoMethod(tmpl, "fd_advise", WASI::FdAdvise);
+  SetFunction<FdAdvise>(FdAdvise, env, "fd_advise", tmpl);
   env->SetProtoMethod(tmpl, "fd_allocate", WASI::FdAllocate);
   env->SetProtoMethod(tmpl, "fd_close", WASI::FdClose);
   env->SetProtoMethod(tmpl, "fd_datasync", WASI::FdDatasync);
@@ -1696,7 +1791,7 @@ static void Initialize(Local<Object> target,
   env->SetProtoMethod(tmpl, "fd_read", WASI::FdRead);
   env->SetProtoMethod(tmpl, "fd_readdir", WASI::FdReaddir);
   env->SetProtoMethod(tmpl, "fd_renumber", WASI::FdRenumber);
-  env->SetProtoMethod(tmpl, "fd_seek", WASI::FdSeek);
+  SetFunction<FdSeek>(FdSeek, env, "fd_seek", tmpl);
   env->SetProtoMethod(tmpl, "fd_sync", WASI::FdSync);
   env->SetProtoMethod(tmpl, "fd_tell", WASI::FdTell);
   env->SetProtoMethod(tmpl, "fd_write", WASI::FdWrite);

src/node_wasi.h

@@ -23,13 +23,11 @@ class WASI : public BaseObject,
   SET_MEMORY_INFO_NAME(WASI)
   SET_SELF_SIZE(WASI)
 
-  static void ArgsGet(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ArgsSizesGet(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ClockResGet(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ClockTimeGet(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void EnvironGet(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void EnvironSizesGet(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void FdAdvise(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void FdAllocate(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void FdClose(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void FdDatasync(const v8::FunctionCallbackInfo<v8::Value>& args);
@@ -82,6 +80,12 @@ class WASI : public BaseObject,
   void IncreaseAllocatedSize(size_t size);
   void DecreaseAllocatedSize(size_t size);
 
+  uvwasi_errno_t backingStore(char** store, size_t* byte_length);
+  uvwasi_t uvw_;
+  v8::Global<v8::WasmMemoryObject> memory_;
+  uvwasi_mem_t alloc_info_;
+  size_t current_uvwasi_memory_ = 0;
+
  private:
   ~WASI() override;
   inline void readUInt8(char* memory, uint8_t* value, uint32_t offset);
@@ -92,11 +96,6 @@ class WASI : public BaseObject,
   inline void writeUInt16(char* memory, uint16_t value, uint32_t offset);
   inline void writeUInt32(char* memory, uint32_t value, uint32_t offset);
   inline void writeUInt64(char* memory, uint64_t value, uint32_t offset);
-  uvwasi_errno_t backingStore(char** store, size_t* byte_length);
-  uvwasi_t uvw_;
-  v8::Global<v8::WasmMemoryObject> memory_;
-  uvwasi_mem_t alloc_info_;
-  size_t current_uvwasi_memory_ = 0;
 };
 
 

test/wasi/Makefile

@@ -1,12 +1,13 @@
 CC = /opt/wasi-sdk/bin/clang
-TARGET = wasm32-unknown-wasi
+TARGET = wasm32-wasi
 SYSROOT =
+CFLAGS = -D_WASI_EMULATED_PROCESS_CLOCKS -lwasi-emulated-process-clocks
 
 OBJ = $(patsubst c/%.c, wasm/%.wasm, $(wildcard c/*.c))
 all: $(OBJ)
 
 wasm/%.wasm : c/%.c
-	$(CC) $< --target=$(TARGET) --sysroot=$(SYSROOT) -s -o $@
+	$(CC) $< $(CFLAGS) --target=$(TARGET) --sysroot=$(SYSROOT) -s -o $@
 
 .PHONY clean:
 	rm -f $(OBJ)

test/wasi/test-wasi.js

@@ -50,6 +50,7 @@ if (process.argv[2] === 'wasi-child') {
       opts.input = options.stdin;
 
     const child = cp.spawnSync(process.execPath, [
+      ...process.argv.slice(1, -1),
       '--experimental-wasi-unstable-preview1',
       __filename,
       'wasi-child',