react-native-wgpu 0.2.1 → 0.2.3

package/cpp/dawn/webgpu_cpp_print.h

@@ -341,6 +341,35 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ComponentSwizzle value) {
+      switch (value) {
+      case ComponentSwizzle::Undefined:
+        o << "ComponentSwizzle::Undefined";
+        break;
+      case ComponentSwizzle::Zero:
+        o << "ComponentSwizzle::Zero";
+        break;
+      case ComponentSwizzle::One:
+        o << "ComponentSwizzle::One";
+        break;
+      case ComponentSwizzle::R:
+        o << "ComponentSwizzle::R";
+        break;
+      case ComponentSwizzle::G:
+        o << "ComponentSwizzle::G";
+        break;
+      case ComponentSwizzle::B:
+        o << "ComponentSwizzle::B";
+        break;
+      case ComponentSwizzle::A:
+        o << "ComponentSwizzle::A";
+        break;
+          default:
+            o << "ComponentSwizzle::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<ComponentSwizzle>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, CompositeAlphaMode value) {
       switch (value) {
       case CompositeAlphaMode::Auto:
@@ -424,6 +453,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, DynamicBindingKind value) {
+      switch (value) {
+      case DynamicBindingKind::Undefined:
+        o << "DynamicBindingKind::Undefined";
+        break;
+      case DynamicBindingKind::SampledTexture:
+        o << "DynamicBindingKind::SampledTexture";
+        break;
+          default:
+            o << "DynamicBindingKind::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<DynamicBindingKind>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ErrorFilter value) {
       switch (value) {
       case ErrorFilter::Validation:
@@ -503,15 +546,15 @@ namespace wgpu {
   template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, FeatureName value) {
       switch (value) {
+      case FeatureName::CoreFeaturesAndLimits:
+        o << "FeatureName::CoreFeaturesAndLimits";
+        break;
       case FeatureName::DepthClipControl:
         o << "FeatureName::DepthClipControl";
         break;
       case FeatureName::Depth32FloatStencil8:
         o << "FeatureName::Depth32FloatStencil8";
         break;
-      case FeatureName::TimestampQuery:
-        o << "FeatureName::TimestampQuery";
-        break;
       case FeatureName::TextureCompressionBC:
         o << "FeatureName::TextureCompressionBC";
         break;
@@ -527,6 +570,9 @@ namespace wgpu {
       case FeatureName::TextureCompressionASTCSliced3D:
         o << "FeatureName::TextureCompressionASTCSliced3D";
         break;
+      case FeatureName::TimestampQuery:
+        o << "FeatureName::TimestampQuery";
+        break;
       case FeatureName::IndirectFirstInstance:
         o << "FeatureName::IndirectFirstInstance";
         break;
@@ -554,8 +600,14 @@ namespace wgpu {
       case FeatureName::Subgroups:
         o << "FeatureName::Subgroups";
         break;
-      case FeatureName::CoreFeaturesAndLimits:
-        o << "FeatureName::CoreFeaturesAndLimits";
+      case FeatureName::TextureFormatsTier1:
+        o << "FeatureName::TextureFormatsTier1";
+        break;
+      case FeatureName::TextureFormatsTier2:
+        o << "FeatureName::TextureFormatsTier2";
+        break;
+      case FeatureName::PrimitiveIndex:
+        o << "FeatureName::PrimitiveIndex";
         break;
       case FeatureName::DawnInternalUsages:
         o << "FeatureName::DawnInternalUsages";
@@ -727,6 +779,12 @@ namespace wgpu {
         break;
       case FeatureName::DawnDeviceAllocatorControl:
         o << "FeatureName::DawnDeviceAllocatorControl";
+        break;
+      case FeatureName::TextureComponentSwizzle:
+        o << "FeatureName::TextureComponentSwizzle";
+        break;
+      case FeatureName::ChromiumExperimentalBindless:
+        o << "FeatureName::ChromiumExperimentalBindless";
         break;
           default:
             o << "FeatureName::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<FeatureName>::type>(value);
@@ -785,6 +843,23 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, InstanceFeatureName value) {
+      switch (value) {
+      case InstanceFeatureName::TimedWaitAny:
+        o << "InstanceFeatureName::TimedWaitAny";
+        break;
+      case InstanceFeatureName::ShaderSourceSPIRV:
+        o << "InstanceFeatureName::ShaderSourceSPIRV";
+        break;
+      case InstanceFeatureName::MultipleDevicesPerAdapter:
+        o << "InstanceFeatureName::MultipleDevicesPerAdapter";
+        break;
+          default:
+            o << "InstanceFeatureName::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<InstanceFeatureName>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, LoadOp value) {
       switch (value) {
       case LoadOp::Undefined:
@@ -896,6 +971,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, PredefinedColorSpace value) {
+      switch (value) {
+      case PredefinedColorSpace::SRGB:
+        o << "PredefinedColorSpace::SRGB";
+        break;
+      case PredefinedColorSpace::DisplayP3:
+        o << "PredefinedColorSpace::DisplayP3";
+        break;
+          default:
+            o << "PredefinedColorSpace::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<PredefinedColorSpace>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, PresentMode value) {
       switch (value) {
       case PresentMode::Undefined:
@@ -1180,8 +1269,14 @@ namespace wgpu {
       case SType::SurfaceSourceXCBWindow:
         o << "SType::SurfaceSourceXCBWindow";
         break;
-      case SType::AdapterPropertiesSubgroups:
-        o << "SType::AdapterPropertiesSubgroups";
+      case SType::SurfaceColorManagement:
+        o << "SType::SurfaceColorManagement";
+        break;
+      case SType::RequestAdapterWebXROptions:
+        o << "SType::RequestAdapterWebXROptions";
+        break;
+      case SType::CompatibilityModeLimits:
+        o << "SType::CompatibilityModeLimits";
         break;
       case SType::TextureBindingViewDimensionDescriptor:
         o << "SType::TextureBindingViewDimensionDescriptor";
@@ -1392,6 +1487,33 @@ namespace wgpu {
         break;
       case SType::RequestAdapterWebGPUBackendOptions:
         o << "SType::RequestAdapterWebGPUBackendOptions";
+        break;
+      case SType::DawnFakeDeviceInitializeErrorForTesting:
+        o << "SType::DawnFakeDeviceInitializeErrorForTesting";
+        break;
+      case SType::TextureComponentSwizzleDescriptor:
+        o << "SType::TextureComponentSwizzleDescriptor";
+        break;
+      case SType::SharedTextureMemoryD3D11BeginState:
+        o << "SType::SharedTextureMemoryD3D11BeginState";
+        break;
+      case SType::DawnConsumeAdapterDescriptor:
+        o << "SType::DawnConsumeAdapterDescriptor";
+        break;
+      case SType::BindGroupLayoutDynamicBindingArray:
+        o << "SType::BindGroupLayoutDynamicBindingArray";
+        break;
+      case SType::DynamicBindingArrayLimits:
+        o << "SType::DynamicBindingArrayLimits";
+        break;
+      case SType::BindGroupDynamicBindingArray:
+        o << "SType::BindGroupDynamicBindingArray";
+        break;
+      case SType::TexelBufferBindingEntry:
+        o << "SType::TexelBufferBindingEntry";
+        break;
+      case SType::TexelBufferBindingLayout:
+        o << "SType::TexelBufferBindingLayout";
         break;
           default:
             o << "SType::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<SType>::type>(value);
@@ -1412,6 +1534,12 @@ namespace wgpu {
         break;
       case SubgroupMatrixComponentType::I32:
         o << "SubgroupMatrixComponentType::I32";
+        break;
+      case SubgroupMatrixComponentType::U8:
+        o << "SubgroupMatrixComponentType::U8";
+        break;
+      case SubgroupMatrixComponentType::I8:
+        o << "SubgroupMatrixComponentType::I8";
         break;
           default:
             o << "SubgroupMatrixComponentType::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<SubgroupMatrixComponentType>::type>(value);
@@ -1445,6 +1573,23 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, TexelBufferAccess value) {
+      switch (value) {
+      case TexelBufferAccess::Undefined:
+        o << "TexelBufferAccess::Undefined";
+        break;
+      case TexelBufferAccess::ReadOnly:
+        o << "TexelBufferAccess::ReadOnly";
+        break;
+      case TexelBufferAccess::ReadWrite:
+        o << "TexelBufferAccess::ReadWrite";
+        break;
+          default:
+            o << "TexelBufferAccess::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<TexelBufferAccess>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, TextureAspect value) {
       switch (value) {
       case TextureAspect::Undefined:
@@ -1511,6 +1656,12 @@ namespace wgpu {
       case TextureFormat::R8Sint:
         o << "TextureFormat::R8Sint";
         break;
+      case TextureFormat::R16Unorm:
+        o << "TextureFormat::R16Unorm";
+        break;
+      case TextureFormat::R16Snorm:
+        o << "TextureFormat::R16Snorm";
+        break;
       case TextureFormat::R16Uint:
         o << "TextureFormat::R16Uint";
         break;
@@ -1541,6 +1692,12 @@ namespace wgpu {
       case TextureFormat::R32Sint:
         o << "TextureFormat::R32Sint";
         break;
+      case TextureFormat::RG16Unorm:
+        o << "TextureFormat::RG16Unorm";
+        break;
+      case TextureFormat::RG16Snorm:
+        o << "TextureFormat::RG16Snorm";
+        break;
       case TextureFormat::RG16Uint:
         o << "TextureFormat::RG16Uint";
         break;
@@ -1592,6 +1749,12 @@ namespace wgpu {
       case TextureFormat::RG32Sint:
         o << "TextureFormat::RG32Sint";
         break;
+      case TextureFormat::RGBA16Unorm:
+        o << "TextureFormat::RGBA16Unorm";
+        break;
+      case TextureFormat::RGBA16Snorm:
+        o << "TextureFormat::RGBA16Snorm";
+        break;
       case TextureFormat::RGBA16Uint:
         o << "TextureFormat::RGBA16Uint";
         break;
@@ -1784,24 +1947,6 @@ namespace wgpu {
       case TextureFormat::ASTC12x12UnormSrgb:
         o << "TextureFormat::ASTC12x12UnormSrgb";
         break;
-      case TextureFormat::R16Unorm:
-        o << "TextureFormat::R16Unorm";
-        break;
-      case TextureFormat::RG16Unorm:
-        o << "TextureFormat::RG16Unorm";
-        break;
-      case TextureFormat::RGBA16Unorm:
-        o << "TextureFormat::RGBA16Unorm";
-        break;
-      case TextureFormat::R16Snorm:
-        o << "TextureFormat::R16Snorm";
-        break;
-      case TextureFormat::RG16Snorm:
-        o << "TextureFormat::RG16Snorm";
-        break;
-      case TextureFormat::RGBA16Snorm:
-        o << "TextureFormat::RGBA16Snorm";
-        break;
       case TextureFormat::R8BG8Biplanar420Unorm:
         o << "TextureFormat::R8BG8Biplanar420Unorm";
         break;
@@ -1890,6 +2035,20 @@ namespace wgpu {
       return o;
   }
   template <typename CharT, typename Traits>
+  std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, ToneMappingMode value) {
+      switch (value) {
+      case ToneMappingMode::Standard:
+        o << "ToneMappingMode::Standard";
+        break;
+      case ToneMappingMode::Extended:
+        o << "ToneMappingMode::Extended";
+        break;
+          default:
+            o << "ToneMappingMode::" << std::showbase << std::hex << std::setfill('0') << std::setw(4) << static_cast<typename std::underlying_type<ToneMappingMode>::type>(value);
+      }
+      return o;
+  }
+  template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, VertexFormat value) {
       switch (value) {
       case VertexFormat::Uint8:
@@ -2072,6 +2231,12 @@ namespace wgpu {
       case WGSLLanguageFeatureName::SizedBindingArray:
         o << "WGSLLanguageFeatureName::SizedBindingArray";
         break;
+      case WGSLLanguageFeatureName::TexelBuffers:
+        o << "WGSLLanguageFeatureName::TexelBuffers";
+        break;
+      case WGSLLanguageFeatureName::ChromiumPrint:
+        o << "WGSLLanguageFeatureName::ChromiumPrint";
+        break;
       case WGSLLanguageFeatureName::ChromiumTestingUnimplemented:
         o << "WGSLLanguageFeatureName::ChromiumTestingUnimplemented";
         break;
@@ -2188,6 +2353,14 @@ namespace wgpu {
     o << "QueryResolve";
     value &= ~BufferUsage::QueryResolve;
   }
+  if (value & BufferUsage::TexelBuffer) {
+    if (!first) {
+      o << "|";
+    }
+    first = false;
+    o << "TexelBuffer";
+    value &= ~BufferUsage::TexelBuffer;
+  }
 
     if (static_cast<bool>(value)) {
       if (!first) {
@@ -2518,6 +2691,10 @@ namespace wgpu {
     return o;
   }
 
+}  // namespace wgpu
+
+namespace wgpu {
+
   template <typename CharT, typename Traits>
   std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& o, StringView value) {
       o << std::string_view(value);

package/cpp/dawn_logging.cpp

@@ -1,5 +1,7 @@
+#include <cstdio>
 #include <sstream>
 #include <string>
+#include <utility>
 
 #ifdef __ANDROID__
 #include <android/log.h>
@@ -21,10 +23,8 @@ class LogMessage {
 public:
     explicit LogMessage(LogSeverity severity);
     ~LogMessage();
-    
     LogMessage(LogMessage&& other);
     LogMessage& operator=(LogMessage&& other);
-    
     template <typename T>
     LogMessage& operator<<(T&& value) {
         mStream << value;
@@ -34,7 +34,6 @@ public:
 private:
     LogMessage(const LogMessage& other) = delete;
     LogMessage& operator=(const LogMessage& other) = delete;
-    
     LogSeverity mSeverity;
     std::ostringstream mStream;
 };
@@ -42,7 +41,7 @@ private:
 // Implementation of LogMessage methods
 LogMessage::LogMessage(LogSeverity severity) : mSeverity(severity) {}
 
-LogMessage::LogMessage(LogMessage&& other) 
+LogMessage::LogMessage(LogMessage&& other)
     : mSeverity(other.mSeverity), mStream(std::move(other.mStream)) {}
 
 LogMessage& LogMessage::operator=(LogMessage&& other) {
@@ -55,11 +54,9 @@ LogMessage& LogMessage::operator=(LogMessage&& other) {
 
 LogMessage::~LogMessage() {
     std::string fullMessage = mStream.str();
-    
     if (fullMessage.empty()) {
         return;
     }
-    
     const char* severityName;
     switch (mSeverity) {
         case LogSeverity::Debug: severityName = "Debug"; break;

package/cpp/jsi/RNFHybridObject.cpp

@@ -5,9 +5,10 @@
 #include "RNFJSIConverter.h"
 #include "WGPULogger.h"
 
-#include <vector>
+#include <unordered_map>
 #include <utility>
 #include <string>
+#include <vector>
 
 namespace margelo {
 

package/cpp/jsi/RNFHybridObject.h

@@ -65,6 +65,12 @@ public:
    */
   virtual std::string toString(jsi::Runtime& runtime);
 
+  /**
+   * 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; }
+
 private:
   static constexpr auto TAG = "HybridObject";
   int _instanceId = 1;

package/cpp/jsi/RNFJSIConverter.h

@@ -29,7 +29,7 @@
 #include "ThreadPool.h"
 
 // This number is the maximum integer that can be represented exactly as a double
-#define MAX_SAFE_INTEGER uint64_t(9007199254740991)
+#define MAX_SAFE_INTEGER static_cast<uint64_t>(9007199254740991)
 
 #if __has_include(<cxxabi.h>)
 #include <cxxabi.h>
@@ -446,7 +446,12 @@ template <typename T> struct JSIConverter<T, std::enable_if_t<is_shared_ptr_to_h
       throw jsi::JSError(runtime, "Cannot convert nullptr to HostObject<" + getFriendlyTypename() + ">!");
     }
 #endif
-    return jsi::Object::createFromHostObject(runtime, arg);
+    auto result = jsi::Object::createFromHostObject(runtime, arg);
+    auto memoryPressure = arg->getMemoryPressure();
+    if (memoryPressure > 0) {
+      result.setExternalMemoryPressure(runtime, memoryPressure);
+    }
+    return result;
   }
 };
 

package/cpp/jsi/RNFPromise.cpp

@@ -4,6 +4,8 @@
 #include "RNFPromise.h"
 #include <future>
 #include <jsi/jsi.h>
+#include <memory>
+#include <string>
 #include <utility>
 #include <vector>
 

package/cpp/jsi/RNFWorkletRuntimeRegistry.cpp

@@ -2,6 +2,7 @@
 // Created by Marc Rousavy on 22.02.24.
 //
 #include "RNFWorkletRuntimeRegistry.h"
+#include <set>
 
 namespace margelo {
 

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -3,6 +3,7 @@
 #include <memory>
 #include <shared_mutex>
 #include <unordered_map>
+#include <utility>
 
 #include "webgpu/webgpu_cpp.h"
 

package/cpp/rnwgpu/api/GPU.cpp

@@ -1,5 +1,9 @@
 #include "GPU.h"
 
+#include <cstdio>
+#include <memory>
+#include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 
@@ -50,7 +54,7 @@ GPU::requestAdapter(
 std::unordered_set<std::string> GPU::getWgslLanguageFeatures() {
   wgpu::SupportedWGSLLanguageFeatures supportedFeatures = {};
   _instance.GetWGSLLanguageFeatures(&supportedFeatures);
-  
+
   std::unordered_set<std::string> result;
   for (size_t i = 0; i < supportedFeatures.featureCount; i++) {
     wgpu::WGSLLanguageFeatureName feature = supportedFeatures.features[i];

package/cpp/rnwgpu/api/GPU.h

@@ -28,9 +28,13 @@ namespace m = margelo;
 class GPU : public m::HybridObject {
 public:
   GPU() : HybridObject("GPU") {
-    wgpu::InstanceDescriptor instanceDesc;
-    instanceDesc.capabilities.timedWaitAnyEnable = true;
-    instanceDesc.capabilities.timedWaitAnyMaxCount = 64;
+    static const auto kTimedWaitAny = wgpu::InstanceFeatureName::TimedWaitAny;
+    wgpu::InstanceDescriptor instanceDesc{.requiredFeatureCount = 1,
+                                          .requiredFeatures = &kTimedWaitAny};
+
+    // For limits:
+    wgpu::InstanceLimits limits{.timedWaitAnyMaxCount = 64};
+    instanceDesc.requiredLimits = &limits;
     _instance = wgpu::CreateInstance(&instanceDesc);
     auto instance = &_instance;
     _async = std::make_shared<AsyncRunner>(instance);

package/cpp/rnwgpu/api/GPUAdapter.cpp

@@ -1,6 +1,9 @@
 #include "GPUAdapter.h"
 
+#include <cstdio>
+#include <memory>
 #include <string>
+#include <unordered_set>
 #include <utility>
 #include <vector>
 

package/cpp/rnwgpu/api/GPUBindGroup.h

@@ -37,6 +37,13 @@ public:
 
   inline const wgpu::BindGroup get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Bind groups store resource bindings and descriptor state
+    // They reference buffers, textures, samplers, etc.
+    // Estimate: 1KB per bind group (descriptor tables and binding state)
+    return 1024;
+  }
+
 private:
   wgpu::BindGroup _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUBindGroupLayout.h

@@ -38,6 +38,13 @@ public:
 
   inline const wgpu::BindGroupLayout get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Bind group layouts define the structure/schema for bind groups
+    // They store binding descriptors, types, and validation info
+    // Estimate: 512 bytes per layout (smaller than actual bind groups)
+    return 512;
+  }
+
 private:
   wgpu::BindGroupLayout _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUBuffer.cpp

@@ -1,5 +1,6 @@
 #include "GPUBuffer.h"
 
+#include <memory>
 #include <utility>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUBuffer.h

@@ -62,6 +62,8 @@ public:
 
   inline const wgpu::Buffer get() { return _instance; }
 
+  size_t getMemoryPressure() override { return static_cast<size_t>(getSize()); }
+
 private:
   wgpu::Buffer _instance;
   std::shared_ptr<AsyncRunner> _async;

package/cpp/rnwgpu/api/GPUCanvasContext.cpp

@@ -1,6 +1,7 @@
 #include "GPUCanvasContext.h"
 #include "Convertors.h"
 #include "RNWebGPUManager.h"
+#include <memory>
 
 #ifdef __APPLE__
 #include "dawn/native/MetalBackend.h"

package/cpp/rnwgpu/api/GPUCanvasContext.h

@@ -2,6 +2,7 @@
 
 #include <memory>
 #include <string>
+#include <utility>
 
 #include "Unions.h"
 

package/cpp/rnwgpu/api/GPUCommandEncoder.cpp

@@ -1,5 +1,7 @@
 #include "GPUCommandEncoder.h"
 
+#include <memory>
+#include <string>
 #include <vector>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUComputePassEncoder.cpp

@@ -1,4 +1,6 @@
 #include "GPUComputePassEncoder.h"
+#include <memory>
+#include <string>
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUComputePipeline.cpp

@@ -1,4 +1,5 @@
 #include "GPUComputePipeline.h"
+#include <memory>
 
 namespace rnwgpu {
 

package/cpp/rnwgpu/api/GPUComputePipeline.h

@@ -45,6 +45,13 @@ public:
 
   inline const wgpu::ComputePipeline get() { return _instance; }
 
+  size_t getMemoryPressure() override {
+    // Compute pipelines contain compiled compute shader state and
+    // driver-specific optimized code
+    // Estimate: 16KB for a typical compute pipeline (single compute shader)
+    return 16 * 1024;
+  }
+
 private:
   wgpu::ComputePipeline _instance;
   std::string _label;

package/cpp/rnwgpu/api/GPUDevice.cpp

@@ -1,5 +1,8 @@
 #include "GPUDevice.h"
 
+#include <memory>
+#include <string>
+#include <unordered_set>
 #include <vector>
 
 #include "Convertors.h"

package/cpp/rnwgpu/api/GPUDeviceLostInfo.cpp

@@ -1,4 +1,5 @@
 #include "GPUDeviceLostInfo.h"
+#include <string>
 
 namespace rnwgpu {
 wgpu::DeviceLostReason getReason();