Reduce memory used by staging belts on Web (#1836)

In particular this prevents crashing with out of memory on a run-away belt memory usage caused by failure to unmap buffers. A bit concerningly, the fix uses our knowledge of how `wgpu::Device::poll` is broken in the current wgpu version.

I took the opportunity to sharpens the definition of `HardwareTier` a bit.

crates/re_renderer/src/config.rs

@@ -2,13 +2,16 @@
 ///
 /// To reduce complexity, we don't do fine-grained feature checks,
 /// but instead support set of features, each a superset of the next.
-#[derive(Clone, Copy, Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum HardwareTier {
-    /// For WebGL and native OpenGL. Maintains strict WebGL capability.
-    Web,
+    /// Limited feature support as provided by WebGL and native GLES2/OpenGL3(ish).
+    Gles,
 
-    /// Run natively with Vulkan/Metal but don't demand anything that isn't widely available.
-    Native,
+    /// Full support of WebGPU spec without additional feature requirements.
+    ///
+    /// Expecting to run either in a stable WebGPU implementation.
+    /// I.e. either natively with Vulkan/Metal or in a browser with WebGPU support.
+    FullWebGpuSupport,
     // Run natively with Vulkan/Metal and require additional features.
     //HighEnd
 }
@@ -17,16 +20,16 @@ impl HardwareTier {
     /// Whether the current hardware tier supports sampling from textures with a sample count higher than 1.
     pub fn support_sampling_msaa_texture(&self) -> bool {
         match self {
-            HardwareTier::Web => false,
-            HardwareTier::Native => true,
+            HardwareTier::Gles => false,
+            HardwareTier::FullWebGpuSupport => true,
         }
     }
 
     /// Whether the current hardware tier supports sampling from textures with a sample count higher than 1.
     pub fn support_depth_readback(&self) -> bool {
         match self {
-            HardwareTier::Web => false,
-            HardwareTier::Native => true,
+            HardwareTier::Gles => false,
+            HardwareTier::FullWebGpuSupport => true,
         }
     }
 }
@@ -35,9 +38,9 @@ impl Default for HardwareTier {
     fn default() -> Self {
         // Use "Basic" tier for actual web but also if someone forces the GL backend!
         if supported_backends() == wgpu::Backends::GL {
-            HardwareTier::Web
+            HardwareTier::Gles
         } else {
-            HardwareTier::Native
+            HardwareTier::FullWebGpuSupport
         }
     }
 }
@@ -72,9 +75,9 @@ impl HardwareTier {
     pub fn required_downlevel_capabilities(self) -> wgpu::DownlevelCapabilities {
         wgpu::DownlevelCapabilities {
             flags: match self {
-                HardwareTier::Web => wgpu::DownlevelFlags::empty(),
+                HardwareTier::Gles => wgpu::DownlevelFlags::empty(),
                 // Require fully WebGPU compliance for the native tier.
-                HardwareTier::Native => wgpu::DownlevelFlags::all(),
+                HardwareTier::FullWebGpuSupport => wgpu::DownlevelFlags::all(),
             },
             limits: Default::default(), // unused so far both here and in wgpu
             shader_model: wgpu::ShaderModel::Sm4,

crates/re_renderer/src/context.rs

@@ -5,7 +5,7 @@ use type_map::concurrent::{self, TypeMap};
 
 use crate::{
     allocator::{CpuWriteGpuReadBelt, GpuReadbackBelt},
-    config::RenderContextConfig,
+    config::{HardwareTier, RenderContextConfig},
     global_bindings::GlobalBindings,
     renderer::Renderer,
     resource_managers::{MeshManager, TextureManager2D},
@@ -78,14 +78,11 @@ impl Renderers {
 impl RenderContext {
     /// Chunk size for our cpu->gpu buffer manager.
     ///
-    /// For native: 32MiB chunk size (as big as a for instance a 2048x1024 float4 texture)
-    /// For web (memory constraint!): 8MiB
-    #[cfg(not(target_arch = "wasm32"))]
+    /// 32MiB chunk size (as big as a for instance a 2048x1024 float4 texture)
+    /// (it's tempting to use something smaller on Web, but this may just cause more
+    /// buffers to be allocated the moment we want to upload a bigger chunk)
     const CPU_WRITE_GPU_READ_BELT_DEFAULT_CHUNK_SIZE: Option<wgpu::BufferSize> =
         wgpu::BufferSize::new(1024 * 1024 * 32);
-    #[cfg(target_arch = "wasm32")]
-    const CPU_WRITE_GPU_READ_BELT_DEFAULT_CHUNK_SIZE: Option<wgpu::BufferSize> =
-        wgpu::BufferSize::new(1024 * 1024 * 8);
 
     /// Chunk size for our gpu->cpu buffer manager.
     ///
@@ -210,14 +207,26 @@ impl RenderContext {
     fn poll_device(&mut self) {
         crate::profile_function!();
 
-        // Browsers don't let us wait for GPU work via `poll`.
-        // * WebGPU: `poll` is a no-op as the spec doesn't specify it at all.
+        // Browsers don't let us wait for GPU work via `poll`:
+        //
+        // * WebGPU: `poll` is a no-op as the spec doesn't specify it at all. Calling it doesn't hurt though.
+        //
         // * WebGL: Internal timeout can't go above a browser specific value.
         //          Since wgpu ran into issues in the past with some browsers returning errors,
         //          it uses a timeout of zero and ignores errors there.
-        //          TODO(andreas): That's not the only thing that's weird with `maintain` in general.
-        //                          See https://github.com/gfx-rs/wgpu/issues/3601
-        if cfg!(target_arch = "wasm32") {
+        //
+        //          This causes unused buffers to be freed immediately, which is wrong but also doesn't hurt
+        //          since WebGL doesn't care about freeing buffers/textures that are still in use.
+        //          Meaning, that from our POV we're actually freeing cpu memory that we wanted to free anyways.
+        //          *More importantly this means that we get buffers from the staging belts back earlier!*
+        //          Therefore, we just always "block" instead on WebGL to free as early as possible,
+        //          knowing that we're not _actually_ blocking.
+        //
+        //          For more details check https://github.com/gfx-rs/wgpu/issues/3601
+        if cfg!(target_arch = "wasm32")
+            && self.shared_renderer_data.config.hardware_tier == HardwareTier::Gles
+        {
+            self.device.poll(wgpu::Maintain::Wait);
             return;
         }