react-native-wgpu 0.2.1 → 0.2.3

package/cpp/rnwgpu/api/GPUQuerySet.h

@@ -44,6 +44,27 @@ public:
 
   inline const wgpu::QuerySet get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    uint32_t count = getCount();
+    wgpu::QueryType type = getType();
+
+    // Estimate bytes per query based on type
+    size_t bytesPerQuery = 8; // Default estimate
+    switch (type) {
+    case wgpu::QueryType::Occlusion:
+      bytesPerQuery = 8; // 64-bit counter
+      break;
+    case wgpu::QueryType::Timestamp:
+      bytesPerQuery = 8; // 64-bit timestamp
+      break;
+    default:
+      bytesPerQuery = 8; // Safe default
+      break;
+    }
+
+    return static_cast<size_t>(count) * bytesPerQuery;
+  }
+
 private:
   wgpu::QuerySet _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUQueue.cpp

@@ -1,6 +1,8 @@
 #include "GPUQueue.h"
 
 #include <limits>
+#include <memory>
+#include <vector>
 
 #include "Convertors.h"
 
@@ -38,7 +40,8 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
 
   // Note that in the JS semantics of WebGPU, writeBuffer works in number of
   // elements of the typed arrays.
-  if (dataOffsetElements > uint64_t(src.size / src.bytesPerElement)) {
+  if (dataOffsetElements >
+      static_cast<uint64_t>(src.size / src.bytesPerElement)) {
     throw std::runtime_error("dataOffset is larger than data's size.");
     return;
   }
@@ -49,7 +52,7 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
   // Size defaults to dataSize - dataOffset. Instead of computing in elements,
   // we directly use it in bytes, and convert the provided value, if any, in
   // bytes.
-  uint64_t size64 = uint64_t(src.size);
+  uint64_t size64 = static_cast<uint64_t>(src.size);
   if (sizeElements.has_value()) {
     if (sizeElements.value() >
         std::numeric_limits<uint64_t>::max() / src.bytesPerElement) {
@@ -59,7 +62,7 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
     size64 = sizeElements.value() * src.bytesPerElement;
   }
 
-  if (size64 > uint64_t(src.size)) {
+  if (size64 > static_cast<uint64_t>(src.size)) {
     throw std::runtime_error("size + dataOffset is larger than data's size.");
     return;
   }
@@ -76,10 +79,12 @@ void GPUQueue::writeBuffer(std::shared_ptr<GPUBuffer> buffer,
 }
 
 std::future<void> GPUQueue::onSubmittedWorkDone() {
-  return _async->runAsync([=] {
+  return _async->runAsync([&] {
     return _instance.OnSubmittedWorkDone(
         wgpu::CallbackMode::WaitAnyOnly,
-        [](wgpu::QueueWorkDoneStatus status) {});
+        [](wgpu::QueueWorkDoneStatus status, wgpu::StringView message) {
+          // Handle the callback if needed
+        });
   });
 }
 

package/cpp/rnwgpu/api/GPURenderBundleEncoder.cpp

@@ -1,5 +1,8 @@
 #include "GPURenderBundleEncoder.h"
 
+#include <memory>
+#include <string>
+
 #include "Convertors.h"
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPURenderPassEncoder.cpp

@@ -1,3 +1,7 @@
+#include <memory>
+#include <string>
+#include <vector>
+
 #include "GPURenderPassEncoder.h"
 #include "Convertors.h"
 
@@ -158,4 +162,4 @@ void GPURenderPassEncoder::drawIndexedIndirect(
   _instance.DrawIndexedIndirect(b, indirectOffset);
 }
 
-} // namespace rnwgpu
+} // namespace rnwgpu

package/cpp/rnwgpu/api/GPURenderPipeline.h

@@ -44,6 +44,14 @@ public:
 
   inline const wgpu::RenderPipeline get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Render pipelines contain compiled shader state, vertex/fragment shaders,
+    // render state, and driver-specific optimized code
+    // Estimate: 24KB for a typical render pipeline with vertex + fragment
+    // shaders
+    return 24 * 1024;
+  }
+
 private:
   wgpu::RenderPipeline _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUShaderModule.cpp

@@ -1,5 +1,6 @@
 #include "GPUShaderModule.h"
 
+#include <memory>
 #include <utility>
 
 namespace rnwgpu {

package/cpp/rnwgpu/api/GPUShaderModule.h

@@ -48,6 +48,14 @@ public:
 
   inline const wgpu::ShaderModule get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Estimate memory usage for compiled shader module
+    // Shaders can vary widely, but a reasonable estimate is 8-16KB for typical
+    // shaders Complex shaders (with many uniforms, textures, or computations)
+    // can be much larger
+    return 12 * 1024; // 12KB estimate for average shader
+  }
+
 private:
   wgpu::ShaderModule _instance;
   std::shared_ptr<AsyncRunner> _async;

package/cpp/rnwgpu/api/GPUTexture.h

@@ -1,5 +1,6 @@
 #pragma once
 
+#include <algorithm>
 #include <memory>
 #include <string>
 
@@ -64,6 +65,81 @@ public:
 
   inline const wgpu::Texture get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Calculate approximate memory usage based on texture properties
+    uint32_t width = getWidth();
+    uint32_t height = getHeight();
+    uint32_t depthOrArrayLayers = getDepthOrArrayLayers();
+    uint32_t mipLevelCount = getMipLevelCount();
+    uint32_t sampleCount = getSampleCount();
+
+    // Estimate bytes per pixel based on format
+    // This is a simplified estimate - actual values depend on the specific
+    // format
+    size_t bytesPerPixel = 4; // Default to RGBA8 format
+    wgpu::TextureFormat format = getFormat();
+    switch (format) {
+    case wgpu::TextureFormat::R8Unorm:
+    case wgpu::TextureFormat::R8Snorm:
+    case wgpu::TextureFormat::R8Uint:
+    case wgpu::TextureFormat::R8Sint:
+      bytesPerPixel = 1;
+      break;
+    case wgpu::TextureFormat::R16Uint:
+    case wgpu::TextureFormat::R16Sint:
+    case wgpu::TextureFormat::R16Float:
+    case wgpu::TextureFormat::RG8Unorm:
+    case wgpu::TextureFormat::RG8Snorm:
+    case wgpu::TextureFormat::RG8Uint:
+    case wgpu::TextureFormat::RG8Sint:
+      bytesPerPixel = 2;
+      break;
+    case wgpu::TextureFormat::RGBA8Unorm:
+    case wgpu::TextureFormat::RGBA8UnormSrgb:
+    case wgpu::TextureFormat::RGBA8Snorm:
+    case wgpu::TextureFormat::RGBA8Uint:
+    case wgpu::TextureFormat::RGBA8Sint:
+    case wgpu::TextureFormat::BGRA8Unorm:
+    case wgpu::TextureFormat::BGRA8UnormSrgb:
+    case wgpu::TextureFormat::RGB10A2Unorm:
+    case wgpu::TextureFormat::R32Float:
+    case wgpu::TextureFormat::R32Uint:
+    case wgpu::TextureFormat::R32Sint:
+    case wgpu::TextureFormat::RG16Uint:
+    case wgpu::TextureFormat::RG16Sint:
+    case wgpu::TextureFormat::RG16Float:
+      bytesPerPixel = 4;
+      break;
+    case wgpu::TextureFormat::RG32Float:
+    case wgpu::TextureFormat::RG32Uint:
+    case wgpu::TextureFormat::RG32Sint:
+    case wgpu::TextureFormat::RGBA16Uint:
+    case wgpu::TextureFormat::RGBA16Sint:
+    case wgpu::TextureFormat::RGBA16Float:
+      bytesPerPixel = 8;
+      break;
+    case wgpu::TextureFormat::RGBA32Float:
+    case wgpu::TextureFormat::RGBA32Uint:
+    case wgpu::TextureFormat::RGBA32Sint:
+      bytesPerPixel = 16;
+      break;
+    default:
+      bytesPerPixel = 4; // Safe default
+      break;
+    }
+
+    // Calculate total memory for all mip levels
+    size_t totalMemory = 0;
+    for (uint32_t mip = 0; mip < mipLevelCount; ++mip) {
+      uint32_t mipWidth = std::max(1u, width >> mip);
+      uint32_t mipHeight = std::max(1u, height >> mip);
+      totalMemory += static_cast<size_t>(mipWidth) * mipHeight *
+                     depthOrArrayLayers * bytesPerPixel * sampleCount;
+    }
+
+    return totalMemory;
+  }
+
 private:
   wgpu::Texture _instance;
   std::string _label;

package/cpp/rnwgpu/api/ImageBitmap.h

@@ -27,6 +27,8 @@ public:
     registerHybridGetter("height", &ImageBitmap::getHeight, this);
   }
 
+  size_t getMemoryPressure() override { return getSize(); }
+
 private:
   ImageData _imageData;
 };

package/cpp/rnwgpu/api/descriptors/Unions.h

@@ -441,7 +441,8 @@ static void convertJSUnionToEnum(const std::string &inUnion,
   } else if (inUnion == "dawn-native") {
     *outEnum = wgpu::FeatureName::DawnNative;
   } else if (inUnion == "chromium-experimental-timestamp-query-inside-passes") {
-    *outEnum = wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses;
+    *outEnum =
+        wgpu::FeatureName::ChromiumExperimentalTimestampQueryInsidePasses;
   } else if (inUnion == "implicit-device-synchronization") {
     *outEnum = wgpu::FeatureName::ImplicitDeviceSynchronization;
   } else if (inUnion == "transient-attachments") {
@@ -613,7 +614,7 @@ static void convertEnumToJSUnion(wgpu::FeatureName inEnum,
   case wgpu::FeatureName::ANGLETextureSharing:
     *outUnion = "angle-texture-sharing";
     break;
-    case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
+  case wgpu::FeatureName::ChromiumExperimentalSubgroupMatrix:
     *outUnion = "chromium-experimental-subgroups-matrix";
     break;
   case wgpu::FeatureName::PixelLocalStorageCoherent:

package/cpp/threading/Dispatcher.cpp

@@ -1,10 +1,11 @@
 //
 // Created by Marc Rousavy on 12.03.24.
 //
+#include <memory>
+#include <unordered_map>
 
 #include "Dispatcher.h"
 
-#include <memory>
 #include "RNFJSIHelper.h"
 
 namespace margelo {

package/cpp/threading/ThreadPool.cpp

@@ -10,6 +10,8 @@
 
 #include <utility>
 #include <algorithm>
+#include <string>
+#include <memory>
 
 namespace margelo {