UNPKG

@tensorflow/tfjs-backend-wasm

Version:

This package adds a WebAssembly backend to TensorFlow.js. It currently supports the following models from our [models](https://github.com/tensorflow/tfjs-models) repo: - BlazeFace - BodyPix - CocoSSD - Face landmarks detection - HandPose - KNN classifier

437 lines 58.1 kB
/** * @license * Copyright 2019 Google LLC. All Rights Reserved. * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * ============================================================================= */ import './flags_wasm'; import { DataStorage, deprecationWarn, engine, env, KernelBackend, util } from '@tensorflow/tfjs-core'; import * as wasmFactoryThreadedSimd_import from '../wasm-out/tfjs-backend-wasm-threaded-simd.js'; // @ts-ignore import { wasmWorkerContents } from '../wasm-out/tfjs-backend-wasm-threaded-simd.worker.js'; import * as wasmFactory_import from '../wasm-out/tfjs-backend-wasm.js'; // This workaround is required for importing in Node.js without using // the node bundle (for testing). This would not be necessary if we // flipped esModuleInterop to true, but we likely can't do that since // google3 does not use it. const wasmFactoryThreadedSimd = (wasmFactoryThreadedSimd_import.default || wasmFactoryThreadedSimd_import); const wasmFactory = (wasmFactory_import.default || wasmFactory_import); export class BackendWasm extends KernelBackend { constructor(wasm) { super(); this.wasm = wasm; // 0 is reserved for null data ids. this.dataIdNextNumber = 1; this.wasm.tfjs.initWithThreadsCount(threadsCount); actualThreadsCount = this.wasm.tfjs.getThreadsCount(); this.dataIdMap = new DataStorage(this, engine()); } write(values, shape, dtype) { const dataId = { id: this.dataIdNextNumber++ }; this.move(dataId, values, shape, dtype, 1); return dataId; } numDataIds() { return this.dataIdMap.numDataIds(); } async time(f) { const start = util.now(); f(); const kernelMs = util.now() - start; return { kernelMs }; } move(dataId, values, shape, dtype, refCount) { const id = this.dataIdNextNumber++; if (dtype === 'string') { const stringBytes = values; this.dataIdMap.set(dataId, { id, stringBytes, shape, dtype, memoryOffset: null, refCount }); return; } const size = util.sizeFromShape(shape); const numBytes = size * util.bytesPerElement(dtype); // `>>> 0` is needed for above 2GB allocations because wasm._malloc returns // a signed int32 instead of an unsigned int32. // https://v8.dev/blog/4gb-wasm-memory const memoryOffset = this.wasm._malloc(numBytes) >>> 0; this.dataIdMap.set(dataId, { id, memoryOffset, shape, dtype, refCount }); this.wasm.tfjs.registerTensor(id, size, memoryOffset); if (values != null) { this.wasm.HEAPU8.set(new Uint8Array(values.buffer, values.byteOffset, numBytes), memoryOffset); } } async read(dataId) { return this.readSync(dataId); } readSync(dataId, start, end) { const { memoryOffset, dtype, shape, stringBytes } = this.dataIdMap.get(dataId); if (dtype === 'string') { // Slice all elements. if ((start == null || start === 0) && (end == null || end >= stringBytes.length)) { return stringBytes; } return stringBytes.slice(start, end); } start = start || 0; end = end || util.sizeFromShape(shape); const bytesPerElement = util.bytesPerElement(dtype); const bytes = this.wasm.HEAPU8.slice(memoryOffset + start * bytesPerElement, memoryOffset + end * bytesPerElement); return typedArrayFromBuffer(bytes.buffer, dtype); } /** * Dispose the memory if the dataId has 0 refCount. Return true if the memory * is released, false otherwise. * @param dataId * @oaram force Optional, remove the data regardless of refCount */ disposeData(dataId, force = false) { if (this.dataIdMap.has(dataId)) { const data = this.dataIdMap.get(dataId); data.refCount--; if (!force && data.refCount > 0) { return false; } this.wasm._free(data.memoryOffset); this.wasm.tfjs.disposeData(data.id); this.dataIdMap.delete(dataId); } return true; } /** Return refCount of a `TensorData`. */ refCount(dataId) { if (this.dataIdMap.has(dataId)) { const tensorData = this.dataIdMap.get(dataId); return tensorData.refCount; } return 0; } incRef(dataId) { const data = this.dataIdMap.get(dataId); if (data != null) { data.refCount++; } } floatPrecision() { return 32; } // Returns the memory offset of a tensor. Useful for debugging and unit // testing. getMemoryOffset(dataId) { return this.dataIdMap.get(dataId).memoryOffset; } dispose() { this.wasm.tfjs.dispose(); if ('PThread' in this.wasm) { this.wasm.PThread.terminateAllThreads(); } this.wasm = null; } memory() { return { unreliable: false }; } /** * Make a tensor info for the output of an op. If `memoryOffset` is not * present, this method allocates memory on the WASM heap. If `memoryOffset` * is present, the memory was allocated elsewhere (in c++) and we just record * the pointer where that memory lives. */ makeOutput(shape, dtype, memoryOffset, values) { let dataId; if (memoryOffset == null) { dataId = this.write(values !== null && values !== void 0 ? values : null, shape, dtype); } else { const id = this.dataIdNextNumber++; dataId = { id }; this.dataIdMap.set(dataId, { id, memoryOffset, shape, dtype, refCount: 1 }); const size = util.sizeFromShape(shape); this.wasm.tfjs.registerTensor(id, size, memoryOffset); } return { dataId, shape, dtype }; } typedArrayFromHeap({ shape, dtype, dataId }) { const buffer = this.wasm.HEAPU8.buffer; const { memoryOffset } = this.dataIdMap.get(dataId); const size = util.sizeFromShape(shape); switch (dtype) { case 'float32': return new Float32Array(buffer, memoryOffset, size); case 'int32': return new Int32Array(buffer, memoryOffset, size); case 'bool': return new Uint8Array(buffer, memoryOffset, size); default: throw new Error(`Unknown dtype ${dtype}`); } } } function createInstantiateWasmFunc(path) { // this will be replace by rollup plugin patchWechatWebAssembly in // minprogram's output. // tslint:disable-next-line:no-any return (imports, callback) => { util.fetch(path, { credentials: 'same-origin' }).then((response) => { if (!response['ok']) { imports.env.a(`failed to load wasm binary file at '${path}'`); } response.arrayBuffer().then(binary => { WebAssembly.instantiate(binary, imports).then(output => { callback(output.instance, output.module); }); }); }); return {}; }; } /** * Returns the path of the WASM binary. * @param simdSupported whether SIMD is supported * @param threadsSupported whether multithreading is supported * @param wasmModuleFolder the directory containing the WASM binaries. */ function getPathToWasmBinary(simdSupported, threadsSupported, wasmModuleFolder) { if (wasmPath != null) { // If wasmPath is defined, the user has supplied a full path to // the vanilla .wasm binary. return wasmPath; } let path = 'tfjs-backend-wasm.wasm'; if (simdSupported && threadsSupported) { path = 'tfjs-backend-wasm-threaded-simd.wasm'; } else if (simdSupported) { path = 'tfjs-backend-wasm-simd.wasm'; } if (wasmFileMap != null) { if (wasmFileMap[path] != null) { return wasmFileMap[path]; } } return wasmModuleFolder + path; } /** * Initializes the wasm module and creates the js <--> wasm bridge. * * NOTE: We wrap the wasm module in a object with property 'wasm' instead of * returning Promise<BackendWasmModule> to avoid freezing Chrome (last tested * in Chrome 76). */ export async function init() { const [simdSupported, threadsSupported] = await Promise.all([ env().getAsync('WASM_HAS_SIMD_SUPPORT'), env().getAsync('WASM_HAS_MULTITHREAD_SUPPORT') ]); return new Promise((resolve, reject) => { const factoryConfig = {}; /** * This function overrides the Emscripten module locateFile utility. * @param path The relative path to the file that needs to be loaded. * @param prefix The path to the main JavaScript file's directory. */ factoryConfig.locateFile = (path, prefix) => { if (path.endsWith('.worker.js')) { // Escape '\n' because Blob will turn it into a newline. // There should be a setting for this, but 'endings: "native"' does // not seem to work. const response = wasmWorkerContents.replace(/\n/g, '\\n'); const blob = new Blob([response], { type: 'application/javascript' }); return URL.createObjectURL(blob); } if (path.endsWith('.wasm')) { return getPathToWasmBinary(simdSupported, threadsSupported, wasmPathPrefix != null ? wasmPathPrefix : prefix); } return prefix + path; }; // Use the instantiateWasm override when system fetch is not available. // Reference: // https://github.com/emscripten-core/emscripten/blob/2bca083cbbd5a4133db61fbd74d04f7feecfa907/tests/manual_wasm_instantiate.html#L170 if (customFetch) { factoryConfig.instantiateWasm = createInstantiateWasmFunc(getPathToWasmBinary(simdSupported, threadsSupported, wasmPathPrefix != null ? wasmPathPrefix : '')); } let initialized = false; factoryConfig.onAbort = () => { if (initialized) { // Emscripten already called console.warn so no need to double log. return; } if (initAborted) { // Emscripten calls `onAbort` twice, resulting in double error // messages. return; } initAborted = true; const rejectMsg = 'Make sure the server can serve the `.wasm` file relative to the ' + 'bundled js file. For more details see https://github.com/tensorflow/tfjs/blob/master/tfjs-backend-wasm/README.md#using-bundlers'; reject({ message: rejectMsg }); }; let wasm; // If `wasmPath` has been defined we must initialize the vanilla module. if (threadsSupported && simdSupported && wasmPath == null) { factoryConfig.mainScriptUrlOrBlob = new Blob([`var WasmBackendModuleThreadedSimd = ` + wasmFactoryThreadedSimd.toString()], { type: 'text/javascript' }); wasm = wasmFactoryThreadedSimd(factoryConfig); } else { // The wasmFactory works for both vanilla and SIMD binaries. wasm = wasmFactory(factoryConfig); } // The `wasm` promise will resolve to the WASM module created by // the factory, but it might have had errors during creation. Most // errors are caught by the onAbort callback defined above. // However, some errors, such as those occurring from a // failed fetch, result in this promise being rejected. These are // caught and re-rejected below. wasm.then((module) => { initialized = true; initAborted = false; const voidReturnType = null; // Using the tfjs namespace to avoid conflict with emscripten's API. module.tfjs = { init: module.cwrap('init', null, []), initWithThreadsCount: module.cwrap('init_with_threads_count', null, ['number']), getThreadsCount: module.cwrap('get_threads_count', 'number', []), registerTensor: module.cwrap('register_tensor', null, [ 'number', 'number', 'number', // memoryOffset ]), disposeData: module.cwrap('dispose_data', voidReturnType, ['number']), dispose: module.cwrap('dispose', voidReturnType, []), }; resolve({ wasm: module }); }) .catch(reject); }); } function typedArrayFromBuffer(buffer, dtype) { switch (dtype) { case 'float32': return new Float32Array(buffer); case 'int32': return new Int32Array(buffer); case 'bool': return new Uint8Array(buffer); default: throw new Error(`Unknown dtype ${dtype}`); } } const wasmBinaryNames = [ 'tfjs-backend-wasm.wasm', 'tfjs-backend-wasm-simd.wasm', 'tfjs-backend-wasm-threaded-simd.wasm' ]; let wasmPath = null; let wasmPathPrefix = null; let wasmFileMap = {}; let initAborted = false; let customFetch = false; /** * @deprecated Use `setWasmPaths` instead. * Sets the path to the `.wasm` file which will be fetched when the wasm * backend is initialized. See * https://github.com/tensorflow/tfjs/blob/master/tfjs-backend-wasm/README.md#using-bundlers * for more details. * @param path wasm file path or url * @param usePlatformFetch optional boolean to use platform fetch to download * the wasm file, default to false. * * @doc {heading: 'Environment', namespace: 'wasm'} */ export function setWasmPath(path, usePlatformFetch = false) { deprecationWarn('setWasmPath has been deprecated in favor of setWasmPaths and' + ' will be removed in a future release.'); if (initAborted) { throw new Error('The WASM backend was already initialized. Make sure you call ' + '`setWasmPath()` before you call `tf.setBackend()` or `tf.ready()`'); } wasmPath = path; customFetch = usePlatformFetch; } /** * Configures the locations of the WASM binaries. * * ```js * setWasmPaths({ * 'tfjs-backend-wasm.wasm': 'renamed.wasm', * 'tfjs-backend-wasm-simd.wasm': 'renamed-simd.wasm', * 'tfjs-backend-wasm-threaded-simd.wasm': 'renamed-threaded-simd.wasm' * }); * tf.setBackend('wasm'); * ``` * * @param prefixOrFileMap This can be either a string or object: * - (string) The path to the directory where the WASM binaries are located. * Note that this prefix will be used to load each binary (vanilla, * SIMD-enabled, threading-enabled, etc.). * - (object) Mapping from names of WASM binaries to custom * full paths specifying the locations of those binaries. This is useful if * your WASM binaries are not all located in the same directory, or if your * WASM binaries have been renamed. * @param usePlatformFetch optional boolean to use platform fetch to download * the wasm file, default to false. * * @doc {heading: 'Environment', namespace: 'wasm'} */ export function setWasmPaths(prefixOrFileMap, usePlatformFetch = false) { if (initAborted) { throw new Error('The WASM backend was already initialized. Make sure you call ' + '`setWasmPaths()` before you call `tf.setBackend()` or ' + '`tf.ready()`'); } if (typeof prefixOrFileMap === 'string') { wasmPathPrefix = prefixOrFileMap; } else { wasmFileMap = prefixOrFileMap; const missingPaths = wasmBinaryNames.filter(name => wasmFileMap[name] == null); if (missingPaths.length > 0) { throw new Error(`There were no entries found for the following binaries: ` + `${missingPaths.join(',')}. Please either call setWasmPaths with a ` + `map providing a path for each binary, or with a string indicating ` + `the directory where all the binaries can be found.`); } } customFetch = usePlatformFetch; } /** Used in unit tests. */ export function resetWasmPath() { wasmPath = null; wasmPathPrefix = null; wasmFileMap = {}; customFetch = false; initAborted = false; } let threadsCount = -1; let actualThreadsCount = -1; /** * Sets the number of threads that will be used by XNNPACK to create * threadpool (default to the number of logical CPU cores). * * This must be called before calling `tf.setBackend('wasm')`. */ export function setThreadsCount(numThreads) { threadsCount = numThreads; } /** * Gets the actual threads count that is used by XNNPACK. * * It is set after the backend is intialized. */ export function getThreadsCount() { if (actualThreadsCount === -1) { throw new Error(`WASM backend not initialized.`); } return actualThreadsCount; } //# sourceMappingURL=data:application/json;base64,{"version":3,"file":"backend_wasm.js","sourceRoot":"","sources":["../../../../../tfjs-backend-wasm/src/backend_wasm.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * @license\n * Copyright 2019 Google LLC. All Rights Reserved.\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n * =============================================================================\n */\nimport './flags_wasm';\n\nimport {backend_util, BackendTimingInfo, DataStorage, DataType, deprecationWarn, engine, env, KernelBackend, TensorInfo, util} from '@tensorflow/tfjs-core';\n\nimport {BackendWasmModule, WasmFactoryConfig} from '../wasm-out/tfjs-backend-wasm';\nimport {BackendWasmThreadedSimdModule} from '../wasm-out/tfjs-backend-wasm-threaded-simd';\nimport * as wasmFactoryThreadedSimd_import from '../wasm-out/tfjs-backend-wasm-threaded-simd.js';\n// @ts-ignore\nimport {wasmWorkerContents} from '../wasm-out/tfjs-backend-wasm-threaded-simd.worker.js';\nimport * as wasmFactory_import from '../wasm-out/tfjs-backend-wasm.js';\n\n// This workaround is required for importing in Node.js without using\n// the node bundle (for testing). This would not be necessary if we\n// flipped esModuleInterop to true, but we likely can't do that since\n// google3 does not use it.\nconst wasmFactoryThreadedSimd = (wasmFactoryThreadedSimd_import.default ||\n                                 wasmFactoryThreadedSimd_import) as\n    typeof wasmFactoryThreadedSimd_import.default;\nconst wasmFactory = (wasmFactory_import.default || wasmFactory_import) as\n    typeof wasmFactory_import.default;\n\ninterface TensorData {\n  id: number;\n  memoryOffset: number;\n  shape: number[];\n  dtype: DataType;\n  refCount: number;\n  /** Only used for string tensors, storing encoded bytes. */\n  stringBytes?: Uint8Array[];\n}\n\nexport type DataId = object;  // object instead of {} to force non-primitive.\n\nexport class BackendWasm extends KernelBackend {\n  // 0 is reserved for null data ids.\n  private dataIdNextNumber = 1;\n  dataIdMap: DataStorage<TensorData>;\n\n  constructor(public wasm: BackendWasmModule|BackendWasmThreadedSimdModule) {\n    super();\n    this.wasm.tfjs.initWithThreadsCount(threadsCount);\n    actualThreadsCount = this.wasm.tfjs.getThreadsCount();\n    this.dataIdMap = new DataStorage(this, engine());\n  }\n\n  override write(\n      values: backend_util.BackendValues|null, shape: number[],\n      dtype: DataType): DataId {\n    const dataId = {id: this.dataIdNextNumber++};\n    this.move(dataId, values, shape, dtype, 1);\n    return dataId;\n  }\n\n  override numDataIds(): number {\n    return this.dataIdMap.numDataIds();\n  }\n\n  override async time(f: () => void): Promise<BackendTimingInfo> {\n    const start = util.now();\n    f();\n    const kernelMs = util.now() - start;\n    return {kernelMs};\n  }\n\n  override move(\n      dataId: DataId, values: backend_util.BackendValues|null, shape: number[],\n      dtype: DataType, refCount: number): void {\n    const id = this.dataIdNextNumber++;\n    if (dtype === 'string') {\n      const stringBytes = values as Uint8Array[];\n      this.dataIdMap.set(\n          dataId,\n          {id, stringBytes, shape, dtype, memoryOffset: null, refCount});\n      return;\n    }\n\n    const size = util.sizeFromShape(shape);\n    const numBytes = size * util.bytesPerElement(dtype);\n\n    // `>>> 0` is needed for above 2GB allocations because wasm._malloc returns\n    // a signed int32 instead of an unsigned int32.\n    // https://v8.dev/blog/4gb-wasm-memory\n    const memoryOffset = this.wasm._malloc(numBytes) >>> 0;\n\n    this.dataIdMap.set(dataId, {id, memoryOffset, shape, dtype, refCount});\n\n    this.wasm.tfjs.registerTensor(id, size, memoryOffset);\n\n    if (values != null) {\n      this.wasm.HEAPU8.set(\n          new Uint8Array(\n              (values as backend_util.TypedArray).buffer,\n              (values as backend_util.TypedArray).byteOffset, numBytes),\n          memoryOffset);\n    }\n  }\n\n  override async read(dataId: DataId): Promise<backend_util.BackendValues> {\n    return this.readSync(dataId);\n  }\n\n  override readSync(dataId: DataId, start?: number, end?: number):\n      backend_util.BackendValues {\n    const {memoryOffset, dtype, shape, stringBytes} =\n        this.dataIdMap.get(dataId);\n    if (dtype === 'string') {\n      // Slice all elements.\n      if ((start == null || start === 0) &&\n          (end == null || end >= stringBytes.length)) {\n        return stringBytes;\n      }\n      return stringBytes.slice(start, end);\n    }\n    start = start || 0;\n    end = end || util.sizeFromShape(shape);\n    const bytesPerElement = util.bytesPerElement(dtype);\n    const bytes = this.wasm.HEAPU8.slice(\n        memoryOffset + start * bytesPerElement,\n        memoryOffset + end * bytesPerElement);\n    return typedArrayFromBuffer(bytes.buffer, dtype);\n  }\n\n  /**\n   * Dispose the memory if the dataId has 0 refCount. Return true if the memory\n   * is released, false otherwise.\n   * @param dataId\n   * @oaram force Optional, remove the data regardless of refCount\n   */\n  override disposeData(dataId: DataId, force = false): boolean {\n    if (this.dataIdMap.has(dataId)) {\n      const data = this.dataIdMap.get(dataId);\n      data.refCount--;\n      if (!force && data.refCount > 0) {\n        return false;\n      }\n\n      this.wasm._free(data.memoryOffset);\n      this.wasm.tfjs.disposeData(data.id);\n      this.dataIdMap.delete(dataId);\n    }\n    return true;\n  }\n\n  /** Return refCount of a `TensorData`. */\n  override refCount(dataId: DataId): number {\n    if (this.dataIdMap.has(dataId)) {\n      const tensorData = this.dataIdMap.get(dataId);\n      return tensorData.refCount;\n    }\n    return 0;\n  }\n\n  override incRef(dataId: DataId) {\n    const data = this.dataIdMap.get(dataId);\n    if (data != null) {\n      data.refCount++;\n    }\n  }\n\n  override floatPrecision(): 32 {\n    return 32;\n  }\n\n  // Returns the memory offset of a tensor. Useful for debugging and unit\n  // testing.\n  getMemoryOffset(dataId: DataId): number {\n    return this.dataIdMap.get(dataId).memoryOffset;\n  }\n\n  override dispose() {\n    this.wasm.tfjs.dispose();\n    if ('PThread' in this.wasm) {\n      this.wasm.PThread.terminateAllThreads();\n    }\n    this.wasm = null;\n  }\n\n  override memory() {\n    return {unreliable: false};\n  }\n\n  /**\n   * Make a tensor info for the output of an op. If `memoryOffset` is not\n   * present, this method allocates memory on the WASM heap. If `memoryOffset`\n   * is present, the memory was allocated elsewhere (in c++) and we just record\n   * the pointer where that memory lives.\n   */\n  makeOutput(\n      shape: number[], dtype: DataType, memoryOffset?: number,\n      values?: backend_util.BackendValues): TensorInfo {\n    let dataId: {};\n    if (memoryOffset == null) {\n      dataId = this.write(values ?? null, shape, dtype);\n    } else {\n      const id = this.dataIdNextNumber++;\n      dataId = {id};\n      this.dataIdMap.set(dataId, {id, memoryOffset, shape, dtype, refCount: 1});\n      const size = util.sizeFromShape(shape);\n      this.wasm.tfjs.registerTensor(id, size, memoryOffset);\n    }\n    return {dataId, shape, dtype};\n  }\n\n  typedArrayFromHeap({shape, dtype, dataId}: TensorInfo):\n      backend_util.TypedArray {\n    const buffer = this.wasm.HEAPU8.buffer;\n    const {memoryOffset} = this.dataIdMap.get(dataId);\n    const size = util.sizeFromShape(shape);\n    switch (dtype) {\n      case 'float32':\n        return new Float32Array(buffer, memoryOffset, size);\n      case 'int32':\n        return new Int32Array(buffer, memoryOffset, size);\n      case 'bool':\n        return new Uint8Array(buffer, memoryOffset, size);\n      default:\n        throw new Error(`Unknown dtype ${dtype}`);\n    }\n  }\n}\n\nfunction createInstantiateWasmFunc(path: string) {\n  // this will be replace by rollup plugin patchWechatWebAssembly in\n  // minprogram's output.\n  // tslint:disable-next-line:no-any\n  return (imports: any, callback: any) => {\n    util.fetch(path, {credentials: 'same-origin'}).then((response) => {\n      if (!response['ok']) {\n        imports.env.a(`failed to load wasm binary file at '${path}'`);\n      }\n      response.arrayBuffer().then(binary => {\n        WebAssembly.instantiate(binary, imports).then(output => {\n          callback(output.instance, output.module);\n        });\n      });\n    });\n    return {};\n  };\n}\n\n/**\n * Returns the path of the WASM binary.\n * @param simdSupported whether SIMD is supported\n * @param threadsSupported whether multithreading is supported\n * @param wasmModuleFolder the directory containing the WASM binaries.\n */\nfunction getPathToWasmBinary(\n    simdSupported: boolean, threadsSupported: boolean,\n    wasmModuleFolder: string) {\n  if (wasmPath != null) {\n    // If wasmPath is defined, the user has supplied a full path to\n    // the vanilla .wasm binary.\n    return wasmPath;\n  }\n\n  let path: WasmBinaryName = 'tfjs-backend-wasm.wasm';\n  if (simdSupported && threadsSupported) {\n    path = 'tfjs-backend-wasm-threaded-simd.wasm';\n  } else if (simdSupported) {\n    path = 'tfjs-backend-wasm-simd.wasm';\n  }\n\n  if (wasmFileMap != null) {\n    if (wasmFileMap[path] != null) {\n      return wasmFileMap[path];\n    }\n  }\n\n  return wasmModuleFolder + path;\n}\n\n/**\n * Initializes the wasm module and creates the js <--> wasm bridge.\n *\n * NOTE: We wrap the wasm module in a object with property 'wasm' instead of\n * returning Promise<BackendWasmModule> to avoid freezing Chrome (last tested\n * in Chrome 76).\n */\nexport async function init(): Promise<{wasm: BackendWasmModule}> {\n  const [simdSupported, threadsSupported] = await Promise.all([\n    env().getAsync('WASM_HAS_SIMD_SUPPORT'),\n    env().getAsync('WASM_HAS_MULTITHREAD_SUPPORT')\n  ]);\n\n  return new Promise((resolve, reject) => {\n    const factoryConfig: WasmFactoryConfig = {};\n\n    /**\n     * This function overrides the Emscripten module locateFile utility.\n     * @param path The relative path to the file that needs to be loaded.\n     * @param prefix The path to the main JavaScript file's directory.\n     */\n    factoryConfig.locateFile = (path, prefix) => {\n      if (path.endsWith('.worker.js')) {\n        // Escape '\\n' because Blob will turn it into a newline.\n        // There should be a setting for this, but 'endings: \"native\"' does\n        // not seem to work.\n        const response = (wasmWorkerContents as string).replace(/\\n/g, '\\\\n');\n        const blob = new Blob([response], {type: 'application/javascript'});\n        return URL.createObjectURL(blob);\n      }\n\n      if (path.endsWith('.wasm')) {\n        return getPathToWasmBinary(\n            simdSupported as boolean, threadsSupported as boolean,\n            wasmPathPrefix != null ? wasmPathPrefix : prefix);\n      }\n      return prefix + path;\n    };\n\n    // Use the instantiateWasm override when system fetch is not available.\n    // Reference:\n    // https://github.com/emscripten-core/emscripten/blob/2bca083cbbd5a4133db61fbd74d04f7feecfa907/tests/manual_wasm_instantiate.html#L170\n    if (customFetch) {\n      factoryConfig.instantiateWasm =\n          createInstantiateWasmFunc(getPathToWasmBinary(\n              simdSupported as boolean, threadsSupported as boolean,\n              wasmPathPrefix != null ? wasmPathPrefix : ''));\n    }\n\n    let initialized = false;\n    factoryConfig.onAbort = () => {\n      if (initialized) {\n        // Emscripten already called console.warn so no need to double log.\n        return;\n      }\n      if (initAborted) {\n        // Emscripten calls `onAbort` twice, resulting in double error\n        // messages.\n        return;\n      }\n      initAborted = true;\n      const rejectMsg =\n          'Make sure the server can serve the `.wasm` file relative to the ' +\n          'bundled js file. For more details see https://github.com/tensorflow/tfjs/blob/master/tfjs-backend-wasm/README.md#using-bundlers';\n      reject({message: rejectMsg});\n    };\n\n    let wasm: Promise<BackendWasmModule>;\n    // If `wasmPath` has been defined we must initialize the vanilla module.\n    if (threadsSupported && simdSupported && wasmPath == null) {\n      factoryConfig.mainScriptUrlOrBlob = new Blob(\n          [`var WasmBackendModuleThreadedSimd = ` +\n           wasmFactoryThreadedSimd.toString()],\n          {type: 'text/javascript'});\n      wasm = wasmFactoryThreadedSimd(factoryConfig);\n    } else {\n      // The wasmFactory works for 