react-native-webgpu 0.9.0 → 0.10.0

package/libs/apple/libwebgpu_dawn.xcframework/macos-arm64_x86_64/Headers/webgpu_upstream/webgpu/webgpu_enum_class_bitmasks.h

@@ -0,0 +1,163 @@
+// Copyright 2017 The Dawn & Tint Authors
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this
+//    list of conditions and the following disclaimer.
+//
+// 2. Redistributions in binary form must reproduce the above copyright notice,
+//    this list of conditions and the following disclaimer in the documentation
+//    and/or other materials provided with the distribution.
+//
+// 3. Neither the name of the copyright holder nor the names of its
+//    contributors may be used to endorse or promote products derived from
+//    this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+#ifndef WEBGPU_ENUM_CLASS_BITMASKS_H_
+#define WEBGPU_ENUM_CLASS_BITMASKS_H_
+
+#include <type_traits>
+
+// The operators in wgpu:: namespace need be introduced into other namespaces with
+// using-declarations for C++ Argument Dependent Lookup to work.
+#define WGPU_IMPORT_BITMASK_OPERATORS \
+    using wgpu::operator|;            \
+    using wgpu::operator&;            \
+    using wgpu::operator^;            \
+    using wgpu::operator~;            \
+    using wgpu::operator&=;           \
+    using wgpu::operator|=;           \
+    using wgpu::operator^=;           \
+    using wgpu::HasZeroOrOneBits;
+
+namespace wgpu {
+
+template <typename T>
+struct IsWGPUBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T, typename Enable = void>
+struct LowerBitmask {
+    static constexpr bool enable = false;
+};
+
+template <typename T>
+struct LowerBitmask<T, typename std::enable_if<IsWGPUBitmask<T>::enable>::type> {
+    static constexpr bool enable = true;
+    using type = T;
+    constexpr static T Lower(T t) { return t; }
+};
+
+template <typename T>
+struct BoolConvertible {
+    using Integral = typename std::underlying_type<T>::type;
+
+    explicit constexpr BoolConvertible(Integral value) : value(value) {}
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr operator bool() const { return value != 0; }
+    // NOLINTNEXTLINE(google-explicit-constructor)
+    constexpr operator T() const { return static_cast<T>(value); }
+
+    Integral value;
+};
+
+template <typename T>
+struct LowerBitmask<BoolConvertible<T>> {
+    static constexpr bool enable = true;
+    using type = T;
+    static constexpr type Lower(BoolConvertible<T> t) { return t; }
+};
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator|(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) |
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator&(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) &
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <
+    typename T1,
+    typename T2,
+    typename = typename std::enable_if<LowerBitmask<T1>::enable && LowerBitmask<T2>::enable>::type>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator^(T1 left, T2 right) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(static_cast<Integral>(LowerBitmask<T1>::Lower(left)) ^
+                              static_cast<Integral>(LowerBitmask<T2>::Lower(right)));
+}
+
+template <typename T1>
+constexpr BoolConvertible<typename LowerBitmask<T1>::type> operator~(T1 t) {
+    using T = typename LowerBitmask<T1>::type;
+    using Integral = typename std::underlying_type<T>::type;
+    return BoolConvertible<T>(
+        static_cast<Integral>(~static_cast<Integral>(LowerBitmask<T1>::Lower(t))));
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator&=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l & r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator|=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l | r;
+    return l;
+}
+
+template <
+    typename T,
+    typename T2,
+    typename = typename std::enable_if<IsWGPUBitmask<T>::enable && LowerBitmask<T2>::enable>::type>
+constexpr T& operator^=(T& l, T2 right) {
+    T r = LowerBitmask<T2>::Lower(right);
+    l = l ^ r;
+    return l;
+}
+
+template <typename T>
+constexpr bool HasZeroOrOneBits(T value) {
+    using Integral = typename std::underlying_type<T>::type;
+    return (static_cast<Integral>(value) & (static_cast<Integral>(value) - 1)) == 0;
+}
+
+}  // namespace wgpu
+
+#endif  // WEBGPU_ENUM_CLASS_BITMASKS_H_

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",
@@ -20,11 +20,12 @@
     "apple/**",
     "libs/**",
     "*.podspec",
+    "Package.swift",
     "app.plugin.js",
     "plugin/build/**"
   ],
-  "dawn": "chrome-m152",
-  "dawnCommit": "1e897275172a23f27b0022fa6beae3084ed54a9b",
+  "dawn": "chrome-m154",
+  "dawnCommit": "3d786993a7ded64c4ebb4884b9b079db9ad0e580",
   "scripts": {
     "test": "NODE_OPTIONS='--experimental-require-module' jest -i",
     "test:ref": "REFERENCE=true NODE_OPTIONS='--experimental-require-module' jest -i",
@@ -42,7 +43,8 @@
     "clang-format-android": "find android/cpp/ -iname \"*.h\" -o -iname \"*.m\" -o -iname \"*.cpp\" | xargs clang-format -i",
     "clang-format-common": "find cpp/rnwgpu -iname \"*.h\" -o -iname \"*.m\" -o -iname \"*.cpp\" | xargs clang-format -i",
     "cpplint": "cpplint --linelength=230 --filter=-legal/copyright,-whitespace/indent,-whitespace/comments,-whitespace/ending_newline,-build/include_order,-runtime/references,-readability/todo,-whitespace/blank_line,-whitespace/todo,-runtime/int,-build/c++11,-whitespace/parens --exclude=example --exclude=android/.cxx --exclude=cpp/webgpu --exclude=cpp/dawn --exclude=ios --exclude=android/build --exclude=node_modules --recursive .",
-    "install-dawn": "tsx scripts/install-dawn.ts"
+    "install-dawn": "tsx scripts/install-dawn.ts",
+    "generate-package-swift": "tsx scripts/generate-package-swift.ts"
   },
   "keywords": [
     "react-native",

package/react-native-webgpu.podspec

@@ -14,17 +14,41 @@ Pod::Spec.new do |s|
   s.platforms    = { :ios => min_ios_version_supported, :osx => "10.15", :visionos => "1.0" }
   s.source       = { :git => "https://github.com/wcandillon/react-native-webgpu.git", :tag => "#{s.version}" }
 
-  s.source_files = [
-    "apple/**/*.{h,c,cc,cpp,m,mm,swift}",  
-    "cpp/**/*.{h,cpp}"
-  ]
+  # RN's autolinking and codegen both key off this podspec being present and
+  # supporting the platform (see react-native.config.js docs: there is no way
+  # to disable CocoaPods linking for a dependency without also disabling
+  # codegen for it). So when the app links react-native-webgpu via the local
+  # Swift Package (packages/webgpu/Package.swift) instead of CocoaPods, this
+  # pod still needs to exist to keep the RNWgpuViewSpec codegen output
+  # flowing — it just shouldn't compile or link anything itself, or the app
+  # would get the native module twice. Set RNWGPU_USE_SPM=1 before
+  # `pod install` for that case.
+  if ENV['RNWGPU_USE_SPM']
+    # The Swift package resolves React Native's headers from the
+    # static-library Pods layout (Pods/Headers/Public). With `use_frameworks!`
+    # CocoaPods keeps headers inside each framework instead, so none of those
+    # paths exist and the package fails to compile with header-not-found
+    # errors that don't point back here. Refuse the combination up front.
+    # The React Native template drives `use_frameworks!` from USE_FRAMEWORKS.
+    if ENV['USE_FRAMEWORKS']
+      raise "react-native-webgpu: RNWGPU_USE_SPM needs the static-library Pods layout. " \
+            "Unset USE_FRAMEWORKS (or drop use_frameworks! from the Podfile) to link " \
+            "react-native-webgpu through its Swift package."
+    end
+    s.source_files = "apple/RNWGUIKit.h"
+  else
+    s.source_files = [
+      "apple/**/*.{h,c,cc,cpp,m,mm,swift}",
+      "cpp/**/*.{h,cpp}"
+    ]
 
-  s.vendored_frameworks = 'libs/apple/libwebgpu_dawn.xcframework'
+    s.vendored_frameworks = 'libs/apple/libwebgpu_dawn.xcframework'
 
-  # The VideoPlayer API uses AVFoundation / CoreMedia, and shared-texture
-  # surfaces use CoreVideo (CVPixelBuffer). Link them so their symbols resolve.
-  # ImageIO provides CGImageSource, the image decoder behind createImageBitmap.
-  s.frameworks = "AVFoundation", "CoreMedia", "CoreVideo", "ImageIO"
+    # The VideoPlayer API uses AVFoundation / CoreMedia, and shared-texture
+    # surfaces use CoreVideo (CVPixelBuffer). Link them so their symbols resolve.
+    # ImageIO provides CGImageSource, the image decoder behind createImageBitmap.
+    s.frameworks = "AVFoundation", "CoreMedia", "CoreVideo", "ImageIO"
+  end
 
   s.pod_target_xcconfig = {
     'HEADER_SEARCH_PATHS' => '$(PODS_TARGET_SRCROOT)/cpp',

package/src/Canvas.tsx

@@ -45,12 +45,49 @@ export interface CanvasRef {
   getNativeSurface: () => NativeCanvas;
 }
 
-interface CanvasProps extends ViewProps {
-  transparent?: boolean;
+export type AndroidSurfaceType = "SurfaceView" | "TextureView";
+
+export interface AndroidCanvasProps {
+  /**
+   * Backing view. Defaults to `SurfaceView` when the canvas is opaque and
+   * `TextureView` otherwise, which is the only pairing that composites
+   * correctly in React Native stacking order without further flags.
+   */
+  surfaceType?: AndroidSurfaceType;
+  /**
+   * SurfaceView only: composite above every React Native view in the window,
+   * ignoring `zIndex`. Ignored for TextureView. Defaults to false.
+   */
+  zOrderOnTop?: boolean;
+}
+
+export interface CanvasProps extends ViewProps {
+  /**
+   * Defaults to true. Set to false to alpha-composite the canvas over the
+   * views behind it (pair it with `alphaMode: "premultiplied"` and an alpha-0
+   * clear color). Android and web only; on iOS `alphaMode` alone controls it.
+   */
+  opaque?: boolean;
+  /** Android-only rendering options. Ignored on iOS and web. */
+  android?: AndroidCanvasProps;
   ref?: React.Ref<CanvasRef>;
 }
 
-export const Canvas = ({ transparent, ref, ...props }: CanvasProps) => {
+// Anything else reaching the native component would hit the generated
+// string-enum parser, which aborts on unknown values.
+const resolveSurfaceType = (
+  surfaceType: AndroidSurfaceType | undefined,
+): "auto" | AndroidSurfaceType =>
+  surfaceType === "SurfaceView" || surfaceType === "TextureView"
+    ? surfaceType
+    : "auto";
+
+export const Canvas = ({
+  opaque = true,
+  android,
+  ref,
+  ...props
+}: CanvasProps) => {
   const viewRef = useRef(null);
   const [contextId, _] = useState(() => generateContextId());
   // Retire the native registry entry for this contextId on unmount. When a
@@ -95,7 +132,9 @@ export const Canvas = ({ transparent, ref, ...props }: CanvasProps) => {
       <WebGPUNativeView
         style={{ flex: 1 }}
         contextId={contextId}
-        transparent={!!transparent}
+        opaque={opaque}
+        androidSurfaceType={resolveSurfaceType(android?.surfaceType)}
+        androidZOrderOnTop={!!android?.zOrderOnTop}
       />
     </View>
   );

package/src/WebGPUViewNativeComponent.ts

@@ -1,10 +1,18 @@
 import { codegenNativeComponent } from "react-native";
-import type { Int32 } from "react-native/Libraries/Types/CodegenTypes";
+import type {
+  Int32,
+  WithDefault,
+} from "react-native/Libraries/Types/CodegenTypes";
 import type { ViewProps } from "react-native";
 
 export interface NativeProps extends ViewProps {
   contextId: Int32;
-  transparent: boolean;
+  opaque?: WithDefault<boolean, true>;
+  androidSurfaceType?: WithDefault<
+    "auto" | "SurfaceView" | "TextureView",
+    "auto"
+  >;
+  androidZOrderOnTop?: WithDefault<boolean, false>;
 }
 
 // eslint-disable-next-line import/no-default-export

package/src/WebGPUViewNativeComponent.web.ts

@@ -7,14 +7,23 @@ import { contextIdToId } from "./utils";
 
 export interface NativeProps extends ViewProps {
   contextId: Int32;
-  transparent: boolean;
+  opaque?: boolean;
+  androidSurfaceType?: "auto" | "SurfaceView" | "TextureView";
+  androidZOrderOnTop?: boolean;
 }
 
 // eslint-disable-next-line import/no-default-export
 export default function WebGPUViewNativeComponent(
   props: NativeProps,
 ): React.JSX.Element {
-  const { contextId, style, transparent, ...rest } = props;
+  const {
+    contextId,
+    style,
+    opaque = true,
+    androidSurfaceType: _androidSurfaceType,
+    androidZOrderOnTop: _androidZOrderOnTop,
+    ...rest
+  } = props;
 
   // MakeWebGPUCanvasContext sets the initial drawing-buffer size. Subsequent
   // resizes belong to the renderer so it can recreate depth/MSAA attachments
@@ -25,7 +34,7 @@ export default function WebGPUViewNativeComponent(
     style: {
       ...styles.view,
       ...styles.flex1,
-      ...(transparent === false ? { backgroundColor: "white" } : {}),
+      ...(opaque ? { backgroundColor: "white" } : {}),
       ...(typeof style === "object" ? style : {}),
     },
   });

package/src/index.tsx

@@ -91,6 +91,13 @@ declare global {
   // device creation: adapter.requestDevice({ dawnToggles: { ... } }).
   interface GPUDeviceDescriptor {
     dawnToggles?: GPUDawnTogglesDescriptor;
+    // Non-spec RN extension. Dawn's "implicit-device-synchronization" feature
+    // is requested by default so one device can be handed from the JS thread
+    // to a worklet runtime; it locks device and child-object calls with a
+    // per-device mutex (command encoding excluded: never share an encoder
+    // across threads). Setting this to false disables the locking; only do so
+    // for a device that will never be touched from a worklet runtime.
+    implicitDeviceSynchronization?: boolean;
   }
   // Non-spec extension: camera frames arrive in the sensor's native
   // orientation, which differs between iOS and Android. `rotation` (degrees,

package/src/mock.ts

@@ -2,9 +2,8 @@
 import React from "react";
 import type { ReactNode } from "react";
 import { View } from "react-native";
-import type { ViewProps } from "react-native";
 
-import type { NativeCanvas, RNCanvasContext } from "./Canvas";
+import type { CanvasProps, NativeCanvas, RNCanvasContext } from "./Canvas";
 
 // Jest mock for `react-native-webgpu`.
 //
@@ -23,15 +22,19 @@ export * from "./formats";
 const NOT_AVAILABLE_UNDER_JEST =
   "is not available under Jest - react-native-webgpu has no native implementation in tests (see react-native-webgpu/jestSetup.js)";
 
-export type { CanvasRef, NativeCanvas, RNCanvasContext } from "./Canvas";
-
-interface CanvasProps extends ViewProps {
-  transparent?: boolean;
-  ref?: React.Ref<unknown>;
-}
+export type {
+  AndroidCanvasProps,
+  AndroidSurfaceType,
+  CanvasProps,
+  CanvasRef,
+  NativeCanvas,
+  RNCanvasContext,
+} from "./Canvas";
 
+// Strip the same props the real Canvas keeps off its outer View.
 export const Canvas = ({
-  transparent: _transparent,
+  opaque: _opaque,
+  android: _android,
   ref,
   ...props
 }: CanvasProps) => {

package/cpp/jsi/RuntimeAwareCache.cpp

@@ -1,8 +0,0 @@
-#include "RuntimeAwareCache.h"
-
-namespace rnwgpu {
-
-std::atomic<jsi::Runtime *> BaseRuntimeAwareCache::_mainRuntime{nullptr};
-std::atomic<uint64_t> BaseRuntimeAwareCache::_mainRuntimeGeneration{0};
-
-} // namespace rnwgpu

package/cpp/jsi/RuntimeAwareCache.h

@@ -1,133 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <atomic>
-#include <cassert>
-#include <cstdint>
-#include <memory>
-#include <mutex>
-#include <unordered_map>
-#include <utility>
-
-#include "RuntimeLifecycleMonitor.h"
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-class BaseRuntimeAwareCache {
-public:
-  static void setMainJsRuntime(jsi::Runtime *rt) {
-    // Atomic: hot reload rewrites this from the JS thread while worklet
-    // runtime threads read it concurrently.
-    _mainRuntime.store(rt, std::memory_order_release);
-    // Every (re)installation of the native module starts a new generation.
-    // Callers that hold process-wide state derived from the main runtime
-    // (see StaticRuntimeAwareCache) must key their invalidation on this
-    // counter and NOT on the runtime pointer: when the JS runtime is
-    // destroyed and recreated in-process (expo-updates OTA apply,
-    // DevSettings.reload) the new jsi::Runtime is frequently allocated at
-    // the exact address of the freed one, so a pointer comparison cannot
-    // tell a reload from the steady state.
-    _mainRuntimeGeneration.fetch_add(1, std::memory_order_acq_rel);
-  }
-  static uint64_t getMainJsRuntimeGeneration() {
-    return _mainRuntimeGeneration.load(std::memory_order_acquire);
-  }
-  static jsi::Runtime *getMainJsRuntime() {
-    auto *rt = _mainRuntime.load(std::memory_order_acquire);
-    assert(rt != nullptr &&
-           "Expected main Javascript runtime to be set in the "
-           "BaseRuntimeAwareCache class.");
-
-    return rt;
-  }
-
-private:
-  static std::atomic<jsi::Runtime *> _mainRuntime;
-  static std::atomic<uint64_t> _mainRuntimeGeneration;
-};
-
-/**
- * Provides a way to keep data specific to a jsi::Runtime instance that gets
- * cleaned up when that runtime is destroyed. This is necessary because JSI does
- * not allow for its associated objects to be retained past the runtime
- * lifetime. If an object (e.g. jsi::Values or jsi::Function instances) is kept
- * after the runtime is torn down, its destructor (once it is destroyed
- * eventually) will result in a crash (JSI objects keep a pointer to memory
- * managed by the runtime, accessing that portion of the memory after runtime is
- * deleted is the root cause of that crash).
- *
- * In order to provide an efficient implementation that does not add an overhead
- * for the cases when only a single runtime is used, which is the primary
- * usecase, the following assumption has been made: Only for secondary runtimes
- * we track destruction and clean up the store associated with that runtime. For
- * the first runtime we assume that the object holding the store is destroyed
- * prior to the destruction of that runtime.
- *
- * The above assumption makes it work without any overhead when only single
- * runtime is in use. Specifically, we don't perform any additional operations
- * related to tracking runtime lifecycle when only a single runtime is used.
- */
-template <typename T>
-class RuntimeAwareCache : public BaseRuntimeAwareCache,
-                          public RuntimeLifecycleListener {
-
-public:
-  void onRuntimeDestroyed(jsi::Runtime *rt) override {
-    if (getMainJsRuntime() != rt) {
-      // We are removing a secondary runtime. This is invoked by
-      // RuntimeLifecycleMonitor on the destroyed runtime's thread, which may
-      // run concurrently with get() on another runtime's thread.
-      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
-      _secondaryRuntimeCaches.erase(rt);
-    }
-  }
-
-  ~RuntimeAwareCache() {
-    for (auto &cache : _secondaryRuntimeCaches) {
-      RuntimeLifecycleMonitor::removeListener(
-          *static_cast<jsi::Runtime *>(cache.first), this);
-    }
-  }
-
-  T &get(jsi::Runtime &rt) {
-    // We check if we're accessing the main runtime - this is the happy path
-    // to avoid us having to lookup by runtime for caches that only has a single
-    // runtime
-    if (getMainJsRuntime() == &rt) {
-      return _primaryCache;
-    } else {
-      // Guard the secondary map: it can be mutated concurrently by get()
-      // on a worklet runtime's thread and by onRuntimeDestroyed() when
-      // another secondary runtime is torn down. The main-runtime path above
-      // stays lock-free. References into the map remain valid after the
-      // lock is released (unordered_map never invalidates references on
-      // insert/erase of other keys, and this runtime's entry can only be
-      // erased from this runtime's own thread).
-      std::lock_guard<std::mutex> lock(_secondaryCachesMutex);
-      if (_secondaryRuntimeCaches.count(&rt) == 0) {
-        // we only add listener when the secondary runtime is used, this assumes
-        // that the secondary runtime is terminated first. This lets us avoid
-        // additional complexity for the majority of cases when objects are not
-        // shared between runtimes. Otherwise we'd have to register all objecrts
-        // with the RuntimeMonitor as opposed to only registering ones that are
-        // used in secondary runtime. Note that we can't register listener here
-        // with the primary runtime as it may run on a separate thread.
-        RuntimeLifecycleMonitor::addListener(rt, this);
-
-        T cache;
-        _secondaryRuntimeCaches.emplace(&rt, std::move(cache));
-      }
-      return _secondaryRuntimeCaches.at(&rt);
-    }
-  }
-
-private:
-  std::mutex _secondaryCachesMutex;
-  std::unordered_map<void *, T> _secondaryRuntimeCaches;
-  T _primaryCache;
-};
-
-} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.cpp

@@ -1,72 +0,0 @@
-#include "RuntimeLifecycleMonitor.h"
-
-#include <mutex>
-#include <unordered_map>
-#include <unordered_set>
-#include <utility>
-
-namespace rnwgpu {
-
-static std::unordered_map<jsi::Runtime *,
-                          std::unordered_set<RuntimeLifecycleListener *>>
-    listeners;
-static std::mutex listenersMutex;
-
-struct RuntimeLifecycleMonitorObject : public jsi::HostObject {
-  jsi::Runtime *_rt;
-  explicit RuntimeLifecycleMonitorObject(jsi::Runtime *rt) : _rt(rt) {}
-  ~RuntimeLifecycleMonitorObject() {
-    std::unordered_set<RuntimeLifecycleListener *> listenersCopy;
-    {
-      std::lock_guard<std::mutex> lock(listenersMutex);
-      auto listenersSet = listeners.find(_rt);
-      if (listenersSet != listeners.end()) {
-        listenersCopy = listenersSet->second;
-        listeners.erase(listenersSet);
-      }
-    }
-    for (auto listener : listenersCopy) {
-      listener->onRuntimeDestroyed(_rt);
-    }
-  }
-};
-
-void RuntimeLifecycleMonitor::addListener(jsi::Runtime &rt,
-                                          RuntimeLifecycleListener *listener) {
-  bool shouldInstallMonitor = false;
-  {
-    std::lock_guard<std::mutex> lock(listenersMutex);
-    auto listenersSet = listeners.find(&rt);
-    if (listenersSet == listeners.end()) {
-      std::unordered_set<RuntimeLifecycleListener *> newSet;
-      newSet.insert(listener);
-      listeners.emplace(&rt, std::move(newSet));
-      shouldInstallMonitor = true;
-    } else {
-      listenersSet->second.insert(listener);
-    }
-  }
-  if (shouldInstallMonitor) {
-    // We install a global host object in the provided runtime, this way we can
-    // use that host object destructor to get notified when the runtime is being
-    // terminated. We use a unique name for the object as it gets saved with the
-    // runtime's global object.
-    rt.global().setProperty(
-        rt, "__rnwgpu_rt_lifecycle_monitor",
-        jsi::Object::createFromHostObject(
-            rt, std::make_shared<RuntimeLifecycleMonitorObject>(&rt)));
-  }
-}
-
-void RuntimeLifecycleMonitor::removeListener(
-    jsi::Runtime &rt, RuntimeLifecycleListener *listener) {
-  std::lock_guard<std::mutex> lock(listenersMutex);
-  auto listenersSet = listeners.find(&rt);
-  if (listenersSet == listeners.end()) {
-    // nothing to do here
-  } else {
-    listenersSet->second.erase(listener);
-  }
-}
-
-} // namespace rnwgpu

package/cpp/jsi/RuntimeLifecycleMonitor.h

@@ -1,32 +0,0 @@
-#pragma once
-
-#include <jsi/jsi.h>
-
-#include <memory>
-
-namespace rnwgpu {
-
-namespace jsi = facebook::jsi;
-
-/**
- * Listener interface that allows for getting notified when a jsi::Runtime
- * instance is destroyed.
- */
-struct RuntimeLifecycleListener {
-  virtual ~RuntimeLifecycleListener() {}
-  virtual void onRuntimeDestroyed(jsi::Runtime *) = 0;
-};
-
-/**
- * This class provides an API via static methods for registering and
- * unregistering runtime lifecycle listeners. The listeners can be used to
- * cleanup any data that references a given jsi::Runtime instance before it gets
- * destroyed.
- */
-struct RuntimeLifecycleMonitor {
-  static void addListener(jsi::Runtime &rt, RuntimeLifecycleListener *listener);
-  static void removeListener(jsi::Runtime &rt,
-                             RuntimeLifecycleListener *listener);
-};
-
-} // namespace rnwgpu