🔧

Author: wcandillon

packages/webgpu/cpp/jsi/RNFHybridObject.h

@@ -77,7 +77,7 @@ class HybridObject : public jsi::HostObject, public std::enable_shared_from_this
    * Get the memory pressure of this HostObject in bytes.
    * This is used to inform the JavaScript runtime about memory usage for garbage collection.
    */
-  virtual size_t getMemoryPressure() { return 1024; }
+  virtual size_t getMemoryPressure() = 0;
 
 private:
   static constexpr auto TAG = "HybridObject";

packages/webgpu/cpp/jsi/RNFPointerHolder.h

@@ -16,6 +16,16 @@ namespace margelo {
 namespace jsi = facebook::jsi;
 
 template <typename T> class PointerHolder : public HybridObject {
+public:
+  size_t getMemoryPressure() override {
+    std::unique_lock lock(_mutex);
+    if (_pointer == nullptr) {
+      return 0;
+    }
+    // Default to a small-but-nonzero floor so holders contribute to pressure.
+    return 64 * 1024; // 64KB
+  }
+
 protected:
   // no default constructor
   PointerHolder() = delete;

packages/webgpu/cpp/rnwgpu/api/Canvas.h

@@ -44,6 +44,8 @@ class Canvas : public m::HybridObject {
     registerHybridSetter("height", &Canvas::setHeight, this);
   }
 
+  size_t getMemoryPressure() override { return sizeof(Canvas); }
+
 private:
   void *_surface;
   int _width;

packages/webgpu/cpp/rnwgpu/api/GPU.h

@@ -48,6 +48,11 @@ class GPU : public m::HybridObject {
 
   inline const wgpu::Instance get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Instance discovery spins up adapter caches and driver state.
+    return 512 * 1024; // 512KB baseline
+  }
+
 private:
   wgpu::Instance _instance;
   std::shared_ptr<async::AsyncRunner> _async;

packages/webgpu/cpp/rnwgpu/api/GPUAdapter.h

@@ -48,6 +48,8 @@ class GPUAdapter : public m::HybridObject {
 
   inline const wgpu::Adapter get() { return _instance; }
 
+  size_t getMemoryPressure() override { return 1024; }
+
 private:
   wgpu::Adapter _instance;
   std::shared_ptr<async::AsyncRunner> _async;

packages/webgpu/cpp/rnwgpu/api/GPUAdapterInfo.h

@@ -44,6 +44,12 @@ class GPUAdapterInfo : public m::HybridObject {
                          &GPUAdapterInfo::getIsFallbackAdapter, this);
   }
 
+  size_t getMemoryPressure() override {
+    return sizeof(GPUAdapterInfo) + _vendor.capacity() +
+           _architecture.capacity() + _device.capacity() +
+           _description.capacity();
+  }
+
 private:
   std::string _vendor;
   std::string _architecture;

packages/webgpu/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <string>
 #include <utility>
@@ -46,6 +47,32 @@ class GPUCanvasContext : public m::HybridObject {
     registerHybridMethod("present", &GPUCanvasContext::present, this);
   }
 
+  size_t getMemoryPressure() override {
+    int width = 0;
+    int height = 0;
+
+    if (_surfaceInfo) {
+      auto size = _surfaceInfo->getSize();
+      width = size.width;
+      height = size.height;
+    }
+
+    if (_canvas) {
+      width = std::max(width, _canvas->getWidth());
+      height = std::max(height, _canvas->getHeight());
+    }
+
+    if (width <= 0 || height <= 0) {
+      return 4 * 1024 * 1024; // default to 4MB when size is unknown
+    }
+
+    constexpr size_t kBytesPerPixel = 4; // RGBA8 fallback
+    constexpr size_t kFloor = 4 * 1024 * 1024;
+    size_t estimated = static_cast<size_t>(width) *
+                       static_cast<size_t>(height) * kBytesPerPixel;
+    return std::max(estimated, kFloor);
+  }
+
   // TODO: is this ok?
   inline const wgpu::Surface get() { return nullptr; }
   void configure(std::shared_ptr<GPUCanvasConfiguration> configuration);

packages/webgpu/cpp/rnwgpu/api/GPUCommandBuffer.h

@@ -35,6 +35,8 @@ class GPUCommandBuffer : public m::HybridObject {
 
   inline const wgpu::CommandBuffer get() { return _instance; }
 
+  size_t getMemoryPressure() override { return 1024 * 1024; }
+
 private:
   wgpu::CommandBuffer _instance;
   std::string _label;

packages/webgpu/cpp/rnwgpu/api/GPUCommandEncoder.h

@@ -100,6 +100,8 @@ class GPUCommandEncoder : public m::HybridObject {
 
   inline const wgpu::CommandEncoder get() { return _instance; }
 
+  size_t getMemoryPressure() override { return 1024 * 1024; }
+
 private:
   wgpu::CommandEncoder _instance;
   std::string _label;

packages/webgpu/cpp/rnwgpu/api/GPUCompilationInfo.h

@@ -36,6 +36,15 @@ class GPUCompilationInfo : public m::HybridObject {
     registerHybridGetter("messages", &GPUCompilationInfo::getMessages, this);
   }
 
+  size_t getMemoryPressure() override {
+    size_t total = sizeof(GPUCompilationInfo) +
+                   _messages.capacity() * sizeof(GPUCompilationMessage);
+    for (const auto &message : _messages) {
+      total += message.message.capacity();
+    }
+    return total;
+  }
+
 private:
   std::vector<GPUCompilationMessage> _messages;
   friend class GPUShaderModule;