JavaScript bindings for module API

CMakeLists.txt

@@ -669,6 +669,10 @@ if(EXECUTORCH_BUILD_PYBIND)
   )
 endif()
 
+if(EXECUTORCH_BUILD_WASM)
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/extension/wasm)
+endif()
+
 if(EXECUTORCH_BUILD_EXTENSION_TRAINING)
   add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/extension/training)
 endif()

extension/wasm/CMakeLists.txt

@@ -0,0 +1,44 @@
+
+cmake_minimum_required(VERSION 3.24)
+
+project(executorch_wasm)
+
+if(NOT CMAKE_CXX_STANDARD)
+  set(CMAKE_CXX_STANDARD 17)
+endif()
+
+if(NOT EMSCRIPTEN)
+  message(FATAL_ERROR "Emscripten is required to build this target")
+endif()
+
+# Source root directory for executorch.
+if(NOT EXECUTORCH_ROOT)
+  set(EXECUTORCH_ROOT ${CMAKE_CURRENT_SOURCE_DIR}/../..)
+endif()
+
+include(${EXECUTORCH_ROOT}/tools/cmake/Utils.cmake)
+set(_common_compile_options -Wno-deprecated-declarations -fPIC)
+set(_common_include_directories ${EXECUTORCH_ROOT}/..)
+
+set(link_libraries)
+list(
+  APPEND
+  link_libraries
+  embind
+  executorch_core
+  extension_data_loader
+  portable_ops_lib
+  extension_module_static
+  extension_tensor
+  extension_runner_util
+)
+
+add_library(executorch_wasm OBJECT wasm_bindings.cpp)
+
+target_compile_options(executorch_wasm PUBLIC ${_common_compile_options})
+target_include_directories(executorch_wasm PUBLIC ${_common_include_directories})
+target_link_libraries(executorch_wasm PUBLIC ${link_libraries})
+
+if(BUILD_TESTING)
+  add_subdirectory(test)
+endif()

extension/wasm/build_wasm.sh

@@ -0,0 +1,15 @@
+
+cd "$(dirname "${BASH_SOURCE[0]}")/../../"
+mkdir -p cmake-out-wasm
+cd cmake-out-wasm
+emcmake cmake -DEXECUTORCH_BUILD_WASM=ON \
+    -DEXECUTORCH_BUILD_EXTENSION_DATA_LOADER=ON \
+    -DEXECUTORCH_BUILD_EXTENSION_FLAT_TENSOR=ON \
+    -DEXECUTORCH_BUILD_DEVTOOLS=ON \
+    -DEXECUTORCH_BUILD_EXTENSION_MODULE=ON \
+    -DEXECUTORCH_BUILD_EXTENSION_TENSOR=ON \
+    -DEXECUTORCH_BUILD_EXTENSION_RUNNER_UTIL=ON \
+    -DBUILD_TESTING=ON \
+    -DCMAKE_BUILD_TYPE=Release \
+    ..
+make executorch_wasm_tests -j32

extension/wasm/test/CMakeLists.txt

@@ -0,0 +1,33 @@
+
+set(MODELS_DIR ${CMAKE_CURRENT_BINARY_DIR}/models/)
+
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/models/add_mul.pte ${CMAKE_CURRENT_BINARY_DIR}/models/add.pte
+  COMMAND ${CMAKE_COMMAND} -E make_directory "${MODELS_DIR}"
+  WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/../../..
+  COMMAND python3 -m examples.portable.scripts.export --model_name="add_mul" --output_dir="${MODELS_DIR}"
+  COMMAND python3 -m examples.portable.scripts.export --model_name="add" --output_dir="${MODELS_DIR}"
+)
+
+add_custom_target(executorch_wasm_test_models DEPENDS ${MODELS_DIR}/add_mul.pte ${MODELS_DIR}/add.pte)
+
+add_executable(executorch_wasm_test_lib)
+target_link_libraries(executorch_wasm_test_lib PUBLIC executorch_wasm)
+target_link_options(executorch_wasm_test_lib PUBLIC --embed-file "${MODELS_DIR}@/")
+add_dependencies(executorch_wasm_test_lib executorch_wasm_test_models)
+
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/executorch_wasm.test.js
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/executorch_wasm.test.js ${CMAKE_CURRENT_BINARY_DIR}/executorch_wasm.test.js
+  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/executorch_wasm.test.js
+  COMMENT "Copying executorch_wasm.test.js to build output directory"
+)
+
+add_custom_command(
+  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/package.json
+  COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/package.json ${CMAKE_CURRENT_BINARY_DIR}/package.json
+  DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/package.json
+  COMMENT "Copying package.json to build output directory"
+)
+
+add_custom_target(executorch_wasm_tests DEPENDS executorch_wasm_test_lib ${CMAKE_CURRENT_BINARY_DIR}/executorch_wasm.test.js ${CMAKE_CURRENT_BINARY_DIR}/package.json)

extension/wasm/test/executorch_wasm.test.js

@@ -0,0 +1,211 @@
+
+let et;
+beforeAll((done) => {
+    et = require("./executorch_wasm_test_lib");
+    et.onRuntimeInitialized = () => {
+        done();
+    }
+});
+
+describe("Tensor", () => {
+    test("ones", () => {
+        const tensor = et.FloatTensor.ones([2, 2]);
+        expect(tensor.getData()).toEqual([1, 1, 1, 1]);
+        expect(tensor.getSizes()).toEqual([2, 2]);
+        tensor.delete();
+    });
+
+    test("zeros", () => {
+        const tensor = et.FloatTensor.zeros([2, 2]);
+        expect(tensor.getData()).toEqual([0, 0, 0, 0]);
+        expect(tensor.getSizes()).toEqual([2, 2]);
+        tensor.delete();
+    });
+
+    test("fromArray", () => {
+        const tensor = et.FloatTensor.fromArray([1, 2, 3, 4], [2, 2]);
+        expect(tensor.getData()).toEqual([1, 2, 3, 4]);
+        expect(tensor.getSizes()).toEqual([2, 2]);
+        tensor.delete();
+    });
+
+    test("fromArray wrong size", () => {
+        expect(() => et.FloatTensor.fromArray([1, 2, 3, 4], [3, 2])).toThrow();
+    });
+
+    test("full", () => {
+        const tensor = et.FloatTensor.full([2, 2], 3);
+        expect(tensor.getData()).toEqual([3, 3, 3, 3]);
+        expect(tensor.getSizes()).toEqual([2, 2]);
+        tensor.delete();
+    });
+});
+
+describe("Module", () => {
+    test("getMethods has foward", () => {
+        const module = et.Module.load("add.pte");
+        const methods = module.getMethods();
+        expect(methods).toEqual(["forward"]);
+        module.delete();
+    });
+
+    test("loadMethod forward", () => {
+        const module = et.Module.load("add.pte");
+        expect(() => module.loadMethod("forward")).not.toThrow();
+        module.delete();
+    });
+
+    test("loadMethod does not exist", () => {
+        const module = et.Module.load("add.pte");
+        expect(() => module.loadMethod("does_not_exist")).toThrow();
+        module.delete();
+    });
+
+    describe("MethodMeta", () => {
+        test("name is forward", () => {
+            const module = et.Module.load("add_mul.pte");
+            const methodMeta = module.getMethodMeta("forward");
+            expect(methodMeta.name).toEqual("forward");
+            methodMeta.delete();
+            module.delete();
+        });
+
+        test("numInputs is 3", () => {
+            const module = et.Module.load("add_mul.pte");
+            const methodMeta = module.getMethodMeta("forward");
+            expect(methodMeta.numInputs).toEqual(3);
+            methodMeta.delete();
+            module.delete();
+        });
+
+        test("method does not exist", () => {
+            const module = et.Module.load("add_mul.pte");
+            expect(() => module.getMethodMeta("does_not_exist")).toThrow();
+            module.delete();
+        });
+
+        describe("TensorInfo", () => {
+            test("sizes is 2x2", () => {
+                const module = et.Module.load("add_mul.pte");
+                const methodMeta = module.getMethodMeta("forward");
+                for (var i = 0; i < methodMeta.numInputs; i++) {
+                    const tensorInfo = methodMeta.inputTensorMeta(i);
+                    expect(tensorInfo.sizes).toEqual([2, 2]);
+                    tensorInfo.delete();
+                }
+                methodMeta.delete();
+                module.delete();
+            });
+
+            test("out of range", () => {
+                const module = et.Module.load("add_mul.pte");
+                const methodMeta = module.getMethodMeta("forward");
+                expect(() => methodMeta.inputTensorMeta(3)).toThrow();
+                methodMeta.delete();
+                module.delete();
+            });
+        });
+    });
+
+    describe("execute", () => {
+        test("add normally", () => {
+            const module = et.Module.load("add.pte");
+            const inputs = [et.FloatTensor.ones([1]), et.FloatTensor.ones([1])];
+            const output = module.execute("forward", inputs);
+
+            expect(output.length).toEqual(1);
+            expect(output[0].getData()).toEqual([2]);
+            expect(output[0].getSizes()).toEqual([1]);
+
+            inputs.forEach((input) => input.delete());
+            output.forEach((output) => output.delete());
+            module.delete();
+        });
+
+        test("add_mul normally", () => {
+            const module = et.Module.load("add_mul.pte");
+            const inputs = [et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2])];
+            const output = module.execute("forward", inputs);
+
+            expect(output.length).toEqual(1);
+            expect(output[0].getData()).toEqual([3, 3, 3, 3]);
+            expect(output[0].getSizes()).toEqual([2, 2]);
+
+            inputs.forEach((input) => input.delete());
+            output.forEach((output) => output.delete());
+            module.delete();
+        });
+
+        test("forward directly", () => {
+            const module = et.Module.load("add_mul.pte");
+            const inputs = [et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2])];
+            const output = module.forward(inputs);
+
+            expect(output.length).toEqual(1);
+            expect(output[0].getData()).toEqual([3, 3, 3, 3]);
+            expect(output[0].getSizes()).toEqual([2, 2]);
+
+            inputs.forEach((input) => input.delete());
+            output.forEach((output) => output.delete());
+            module.delete();
+        });
+
+        test("wrong number of inputs", () => {
+            const module = et.Module.load("add_mul.pte");
+            const inputs = [et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2])];
+            expect(() => module.execute("forward", inputs)).toThrow();
+
+            inputs.forEach((input) => input.delete());
+            module.delete();
+        });
+
+        test("wrong input size", () => {
+            const module = et.Module.load("add.pte");
+            const inputs = [et.FloatTensor.ones([2, 1]), et.FloatTensor.ones([2, 1])];
+            expect(() => module.execute("forward", inputs)).toThrow();
+
+            inputs.forEach((input) => input.delete());
+            module.delete();
+        });
+
+        test("wrong input type", () => {
+            const module = et.Module.load("add.pte");
+            const inputs = [et.FloatTensor.ones([1]), et.IntTensor.ones([1])];
+            expect(() => module.execute("forward", inputs)).toThrow();
+
+            inputs.forEach((input) => input.delete());
+            module.delete();
+        });
+
+        test("method does not exist", () => {
+            const module = et.Module.load("add.pte");
+            const inputs = [et.FloatTensor.ones([1]), et.FloatTensor.ones([1])];
+            expect(() => module.execute("does_not_exist", inputs)).toThrow();
+
+            inputs.forEach((input) => input.delete());
+            module.delete();
+        });
+
+        test("output tensor can be reused", () => {
+            const module = et.Module.load("add_mul.pte");
+            const inputs = [et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2]), et.FloatTensor.ones([2, 2])];
+            const output = module.forward(inputs);
+
+            expect(output.length).toEqual(1);
+            expect(output[0].getData()).toEqual([3, 3, 3, 3]);
+            expect(output[0].getSizes()).toEqual([2, 2]);
+
+            const inputs2 = [output[0], output[0], output[0]];
+            const output2 = module.forward(inputs2);
+
+            expect(output2.length).toEqual(1);
+            expect(output2[0].getData()).toEqual([21, 21, 21, 21]);
+            expect(output2[0].getSizes()).toEqual([2, 2]);
+
+            inputs.forEach((input) => input.delete());
+            output.forEach((output) => output.delete());
+            output2.forEach((output) => output.delete());
+            module.delete();
+        });
+    });
+});

extension/wasm/test/package.json

@@ -0,0 +1,5 @@
+{
+  "scripts": {
+    "test": "jest"
+  }
+}