@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
JavaScript
/**
* @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 