[JS OV] Extend js bindings supported platforms (openvinotoolkit#21995)

* Fix npm variables list

* Fix typo

* Provide instructions for js bindings arm compilation

* Remove extra spaces

* Set optimal scope of flags for both archs

* Support windows compilation

* Extend .gitignore

* Unify compilation instruction

* Exclude async infer from windows build

* Enable js on windows

* Activate js validation in windows workflow

* Fix precision

Author: vishniakov-nikolai

.github/workflows/windows.yml

@@ -201,8 +201,7 @@ jobs:
           cmake --build ${{ env.BUILD_DIR }} --parallel --config ${{ env.CMAKE_BUILD_TYPE }} --verbose
 
       - name: CMake configure, build and install - OpenVINO JS API
-        if: ${{ 'false' }} # 128689
-        # if: fromJSON(needs.smart_ci.outputs.affected_components).JS_API
+        if: fromJSON(needs.smart_ci.outputs.affected_components).JS_API
         run:
           cmake -DCPACK_GENERATOR=NPM -DENABLE_SYSTEM_TBB=OFF -UTBB* -S ${{ env.OPENVINO_REPO }} -B ${{ env.BUILD_DIR }}
 

cmake/features.cmake

@@ -177,8 +177,7 @@ ov_dependent_option (ENABLE_SYSTEM_SNAPPY "Enables use of system version of Snap
 ov_dependent_option (ENABLE_PYTHON_PACKAGING "Enables packaging of Python API in APT / YUM" OFF
     "ENABLE_PYTHON;UNIX" OFF)
 
-ov_dependent_option (ENABLE_JS "Enables JS API building" ON
-    "NOT WIN32" OFF)
+ov_option(ENABLE_JS "Enables JS API building" ON)
 
 ov_option(ENABLE_OPENVINO_DEBUG "Enable output for OPENVINO_DEBUG statements" OFF)
 

src/bindings/js/node/.gitignore

@@ -3,3 +3,7 @@ dist
 build
 types
 ov_runtime
+
+
+*.exp
+*.lib

src/bindings/js/node/CMakeLists.txt

@@ -12,6 +12,14 @@ if(CMAKE_COMPILER_IS_GNUCXX AND LINUX AND CMAKE_CXX_COMPILER_VERSION VERSION_LES
     return()
 endif()
 
+if(WIN32)
+    set(CMAKE_JS_LIB ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/node.lib)
+    set(CMAKE_JS_SRC ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/win_delay_load_hook.cc)
+
+    set(CMAKE_JS_NODELIB_DEF ${CMAKE_CURRENT_SOURCE_DIR}/thirdparty/node-lib.def)
+    set(CMAKE_JS_NODELIB_TARGET ${CMAKE_JS_LIB})
+endif()
+
 cmake_minimum_required(VERSION 3.14)
 
 project(ov_node_addon)
@@ -57,6 +65,8 @@ add_library(${PROJECT_NAME} SHARED
     ${CMAKE_CURRENT_SOURCE_DIR}/src/addon.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/element_type.cpp
     ${CMAKE_CURRENT_SOURCE_DIR}/src/partial_shape_wrap.cpp
+
+    ${CMAKE_JS_SRC}
 )
 
 target_include_directories(${PROJECT_NAME} PRIVATE 
@@ -65,7 +75,12 @@ target_include_directories(${PROJECT_NAME} PRIVATE
     "${CMAKE_CURRENT_SOURCE_DIR}/include"
 )
 
-target_link_libraries(${PROJECT_NAME} PRIVATE openvino::runtime)
+target_link_libraries(${PROJECT_NAME} PRIVATE openvino::runtime ${CMAKE_JS_LIB})
+
+if(MSVC AND CMAKE_JS_NODELIB_DEF AND CMAKE_JS_NODELIB_TARGET)
+  # Generate node.lib
+  execute_process(COMMAND ${CMAKE_AR} /def:${CMAKE_JS_NODELIB_DEF} /out:${CMAKE_JS_NODELIB_TARGET} ${CMAKE_STATIC_LINKER_FLAGS})
+endif()
 
 if(CMAKE_COMPILER_IS_GNUCXX OR OV_COMPILER_IS_CLANG)
     ov_add_compiler_flags(-Wno-missing-declarations)

src/bindings/js/node/README.md

@@ -11,8 +11,25 @@
 
 - Make sure that all submodules are updated `git submodule update --init --recursive`
 - Create build dir `mkdir build && cd build`
-- To get binaries for openvinojs-node package run:
-  `cmake  -DCPACK_GENERATOR=NPM -DENABLE_SYSTEM_TBB=OFF -UTBB* -DCMAKE_INSTALL_PREFIX=../src/bindings/js/node/bin ..`
+- To configure binaries building run:
+
+  ### Linux x86, Linux arm, Mac x86, Mac arm
+  ```bash
+  cmake \
+    -DCMAKE_BUILD_TYPE=Release \
+    -DENABLE_FASTER_BUILD=ON \
+    -DCPACK_GENERATOR=NPM \
+    -DENABLE_SYSTEM_TBB=OFF -UTBB* \
+    -DENABLE_TESTS=OFF \
+    -DENABLE_SAMPLES=OFF \
+    -DENABLE_WHEEL=OFF \
+    -DENABLE_PYTHON=OFF \
+    -DENABLE_INTEL_GPU=OFF \
+    -DCMAKE_INSTALL_PREFIX=../src/bindings/js/node/bin \
+    ..
+  ```
+
+- To get binaries for openvinojs-node package run compilation:
   `make --jobs=$(nproc --all) install`
 - Go to npm package folder `cd ../src/bindings/js/node`
 - Now you can install dependencies packages and transpile ts to js code. Run `npm install`

src/bindings/js/node/include/infer_request.hpp

@@ -3,6 +3,7 @@
 
 #pragma once
 #include <napi.h>
+
 #include <thread>
 
 #include "openvino/runtime/infer_request.hpp"
@@ -101,8 +102,11 @@ class InferRequestWrap : public Napi::ObjectWrap<InferRequestWrap> {
     /** @brief  Checks incoming Napi::Value and calls overloaded infer() method */
     Napi::Value infer_dispatch(const Napi::CallbackInfo& info);
 
+// 128760
+#ifndef _WIN32
     /** @brief  Checks incoming Napi::Value and asynchronously returns the result of inference. */
     Napi::Value infer_async(const Napi::CallbackInfo& info);
+#endif
 
     /** @brief Infers specified inputs in synchronous mode.
      * @param inputs  An object with a collection of pairs key (input_name) and a value (tensor, tensor's data)

src/bindings/js/node/src/compiled_model.cpp

@@ -70,7 +70,7 @@ Napi::Value CompiledModelWrap::get_outputs(const Napi::CallbackInfo& info) {
     auto cm_outputs = _compiled_model.outputs();  // Output<Node>
     Napi::Array js_outputs = Napi::Array::New(info.Env(), cm_outputs.size());
 
-    size_t i = 0;
+    uint32_t i = 0;
     for (auto& out : cm_outputs)
         js_outputs[i++] = Output<const ov::Node>::wrap(info.Env(), out);
 
@@ -104,7 +104,7 @@ Napi::Value CompiledModelWrap::get_inputs(const Napi::CallbackInfo& info) {
     auto cm_inputs = _compiled_model.inputs();  // Output<Node>
     Napi::Array js_inputs = Napi::Array::New(info.Env(), cm_inputs.size());
 
-    size_t i = 0;
+    uint32_t i = 0;
     for (auto& out : cm_inputs)
         js_inputs[i++] = Output<const ov::Node>::wrap(info.Env(), out);
 

src/bindings/js/node/src/core_wrap.cpp

@@ -221,7 +221,7 @@ Napi::Value CoreWrap::get_available_devices(const Napi::CallbackInfo& info) {
     const auto& devices = _core.get_available_devices();
     Napi::Array js_devices = Napi::Array::New(info.Env(), devices.size());
 
-    size_t i = 0;
+    uint32_t i = 0;
     for (const auto& dev : devices)
         js_devices[i++] = dev;
 

src/bindings/js/node/src/helper.cpp

@@ -67,7 +67,7 @@ std::vector<size_t> js_to_cpp<std::vector<size_t>>(const Napi::CallbackInfo& inf
 
         std::vector<size_t> nativeArray;
 
-        for (size_t i = 0; i < arrayLength; ++i) {
+        for (uint32_t i = 0; i < arrayLength; ++i) {
             Napi::Value arrayItem = array[i];
             if (!arrayItem.IsNumber()) {
                 OPENVINO_THROW(std::string("Passed array must contain only numbers."));
@@ -107,7 +107,7 @@ std::unordered_set<std::string> js_to_cpp<std::unordered_set<std::string>>(
 
         std::unordered_set<std::string> nativeArray;
 
-        for (size_t i = 0; i < arrayLength; ++i) {
+        for (uint32_t i = 0; i < arrayLength; ++i) {
             Napi::Value arrayItem = array[i];
             if (!arrayItem.IsString()) {
                 OPENVINO_THROW(std::string("Passed array must contain only strings."));
@@ -199,7 +199,7 @@ std::map<std::string, ov::Any> js_to_cpp<std::map<std::string, ov::Any>>(
     const auto& config = elem.ToObject();
     const auto& keys = config.GetPropertyNames();
 
-    for (size_t i = 0; i < keys.Length(); ++i) {
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
         const std::string& option = static_cast<Napi::Value>(keys[i]).ToString();
         properties_to_cpp[option] = js_to_cpp<ov::Any>(config.Get(option), {napi_string});
     }
@@ -216,7 +216,7 @@ Napi::String cpp_to_js<ov::element::Type_t, Napi::String>(const Napi::CallbackIn
 template <>
 Napi::Array cpp_to_js<ov::Shape, Napi::Array>(const Napi::CallbackInfo& info, const ov::Shape shape) {
     auto arr = Napi::Array::New(info.Env(), shape.size());
-    for (size_t i = 0; i < shape.size(); ++i)
+    for (uint32_t i = 0; i < shape.size(); ++i)
         arr[i] = shape[i];
     return arr;
 }
@@ -226,7 +226,7 @@ Napi::Array cpp_to_js<ov::PartialShape, Napi::Array>(const Napi::CallbackInfo& i
     size_t size = shape.size();
     Napi::Array dimensions = Napi::Array::New(info.Env(), size);
 
-    for (size_t i = 0; i < size; i++) {
+    for (uint32_t i = 0; i < size; i++) {
         ov::Dimension dim = shape[i];
 
         if (dim.is_static()) {
@@ -254,7 +254,7 @@ Napi::Array cpp_to_js<ov::Dimension, Napi::Array>(const Napi::CallbackInfo& info
 
     // Indexes looks wierd, but clear assignment,
     // like: interval[0] = value doesn't work here
-    size_t indexes[] = {0, 1};
+    uint32_t indexes[] = {0, 1};
     interval[indexes[0]] = dim.get_min_length();
     interval[indexes[1]] = dim.get_max_length();
 
@@ -270,13 +270,13 @@ ov::TensorVector parse_input_data(const Napi::Value& input) {
     ov::TensorVector parsed_input;
     if (input.IsArray()) {
         auto inputs = input.As<Napi::Array>();
-        for (size_t i = 0; i < inputs.Length(); ++i) {
+        for (uint32_t i = 0; i < inputs.Length(); ++i) {
             parsed_input.emplace_back(cast_to_tensor(static_cast<Napi::Value>(inputs[i])));
         }
     } else if (input.IsObject()) {
         auto inputs = input.ToObject();
         const auto& keys = inputs.GetPropertyNames();
-        for (size_t i = 0; i < keys.Length(); ++i) {
+        for (uint32_t i = 0; i < keys.Length(); ++i) {
             auto value = inputs.Get(static_cast<Napi::Value>(keys[i]).ToString().Utf8Value());
             parsed_input.emplace_back(cast_to_tensor(static_cast<Napi::Value>(value)));
         }

src/bindings/js/node/src/infer_request.cpp

@@ -30,7 +30,10 @@ Napi::Function InferRequestWrap::get_class(Napi::Env env) {
                            InstanceMethod("getInputTensor", &InferRequestWrap::get_input_tensor),
                            InstanceMethod("getOutputTensor", &InferRequestWrap::get_output_tensor),
                            InstanceMethod("infer", &InferRequestWrap::infer_dispatch),
+    //    128760
+#ifndef _WIN32
                            InstanceMethod("inferAsync", &InferRequestWrap::infer_async),
+#endif
                            InstanceMethod("getCompiledModel", &InferRequestWrap::get_compiled_model),
                        });
 }
@@ -171,7 +174,7 @@ Napi::Value InferRequestWrap::infer_dispatch(const Napi::CallbackInfo& info) {
 }
 
 void InferRequestWrap::infer(const Napi::Array& inputs) {
-    for (size_t i = 0; i < inputs.Length(); ++i) {
+    for (uint32_t i = 0; i < inputs.Length(); ++i) {
         auto tensor = value_to_tensor(inputs[i], _infer_request, i);
         _infer_request.set_input_tensor(i, tensor);
     }
@@ -181,7 +184,7 @@ void InferRequestWrap::infer(const Napi::Array& inputs) {
 void InferRequestWrap::infer(const Napi::Object& inputs) {
     const auto& keys = inputs.GetPropertyNames();
 
-    for (size_t i = 0; i < keys.Length(); ++i) {
+    for (uint32_t i = 0; i < keys.Length(); ++i) {
         auto input_name = static_cast<Napi::Value>(keys[i]).ToString().Utf8Value();
         auto value = inputs.Get(input_name);
         auto tensor = value_to_tensor(value, _infer_request, input_name);
@@ -194,7 +197,8 @@ void InferRequestWrap::infer(const Napi::Object& inputs) {
 Napi::Value InferRequestWrap::get_compiled_model(const Napi::CallbackInfo& info) {
     return CompiledModelWrap::wrap(info.Env(), _infer_request.get_compiled_model());
 }
-
+// 128760
+#ifndef _WIN32
 void FinalizerCallback(Napi::Env env, void* finalizeData, TsfnContext* context) {
     context->native_thread.join();
     delete context;
@@ -256,3 +260,4 @@ Napi::Value InferRequestWrap::infer_async(const Napi::CallbackInfo& info) {
     context->native_thread = std::thread(performInferenceThread, context);
     return context->deferred.Promise();
 }
+#endif

src/bindings/js/node/src/model_wrap.cpp

@@ -99,7 +99,7 @@ Napi::Value ModelWrap::get_inputs(const Napi::CallbackInfo& info) {
     auto cm_inputs = _model->inputs();  // Output<Node>
     Napi::Array js_inputs = Napi::Array::New(info.Env(), cm_inputs.size());
 
-    size_t i = 0;
+    uint32_t i = 0;
     for (auto& input : cm_inputs)
         js_inputs[i++] = Output<ov::Node>::wrap(info.Env(), input);
 
@@ -110,7 +110,7 @@ Napi::Value ModelWrap::get_outputs(const Napi::CallbackInfo& info) {
     auto cm_outputs = _model->outputs();  // Output<Node>
     Napi::Array js_outputs = Napi::Array::New(info.Env(), cm_outputs.size());
 
-    size_t i = 0;
+    uint32_t i = 0;
     for (auto& out : cm_outputs)
         js_outputs[i++] = Output<ov::Node>::wrap(info.Env(), out);
 

src/bindings/js/node/tests/infer_request.test.js

@@ -2,6 +2,7 @@
 // Copyright (C) 2018-2023 Intel Corporation
 // SPDX-License-Identifier: Apache-2.0
 
+const os = require('node:os');
 const { addon: ov } = require('..');
 const assert = require('assert');
 const { describe, it } = require('node:test');
@@ -78,35 +79,38 @@ describe('InferRequest', () => {
     });
   });
 
-  it('Test inferAsync(inputData: { [inputName: string]: Tensor })', () => {
-    inferRequestAsync.inferAsync({ data: tensor }).then(result => {
-      assert.ok(result['fc_out'] instanceof ov.Tensor);
-      assert.deepStrictEqual(Object.keys(result), ['fc_out']);
-      assert.deepStrictEqual(result['fc_out'].data.length, 10);}
-    );
-  });
+  // 128760
+  if (os.platform() !== 'win32') {
+    it('Test inferAsync(inputData: { [inputName: string]: Tensor })', () => {
+      inferRequestAsync.inferAsync({ data: tensor }).then(result => {
+        assert.ok(result['fc_out'] instanceof ov.Tensor);
+        assert.deepStrictEqual(Object.keys(result), ['fc_out']);
+        assert.deepStrictEqual(result['fc_out'].data.length, 10);}
+      );
+    });
 
-  it('Test inferAsync(inputData: Tensor[])', () => {
-    inferRequestAsync.inferAsync([ tensor ]).then(result => {
-      assert.ok(result['fc_out'] instanceof ov.Tensor);
-      assert.deepStrictEqual(Object.keys(result), ['fc_out']);
-      assert.deepStrictEqual(result['fc_out'].data.length, 10);
+    it('Test inferAsync(inputData: Tensor[])', () => {
+      inferRequestAsync.inferAsync([ tensor ]).then(result => {
+        assert.ok(result['fc_out'] instanceof ov.Tensor);
+        assert.deepStrictEqual(Object.keys(result), ['fc_out']);
+        assert.deepStrictEqual(result['fc_out'].data.length, 10);
+      });
     });
-  });
 
-  it('Test inferAsync([data]) throws: Cannot create a tensor from the passed Napi::Value.', () => {
-    assert.throws(
-      () => inferRequestAsync.inferAsync(['string']).then(),
-      /Cannot create a tensor from the passed Napi::Value./
-    );
-  });
+    it('Test inferAsync([data]) throws: Cannot create a tensor from the passed Napi::Value.', () => {
+      assert.throws(
+        () => inferRequestAsync.inferAsync(['string']).then(),
+        /Cannot create a tensor from the passed Napi::Value./
+      );
+    });
 
-  it('Test inferAsync({ data: "string"}) throws: Cannot create a tensor from the passed Napi::Value.', () => {
-    assert.throws(
-      () => inferRequestAsync.inferAsync({data: 'string'}).then(),
-      /Cannot create a tensor from the passed Napi::Value./
-    );
-  });
+    it('Test inferAsync({ data: "string"}) throws: Cannot create a tensor from the passed Napi::Value.', () => {
+      assert.throws(
+        () => inferRequestAsync.inferAsync({data: 'string'}).then(),
+        /Cannot create a tensor from the passed Napi::Value./
+      );
+    });
+  }
 
   it('Test setInputTensor(tensor)', () => {
     inferRequest.setInputTensor(tensor);