Arcanization of wgpu core resources

.github/workflows/ci.yml

@@ -10,8 +10,8 @@ on:
 env:
   CARGO_INCREMENTAL: false
   CARGO_TERM_COLOR: always
-  RUST_LOG: info
   RUST_BACKTRACE: full
+  RUST_LOG: info #needed to understand what's going on when tests fail
   MSRV: 1.65
   PKG_CONFIG_ALLOW_CROSS: 1 # allow android to work
   RUSTFLAGS: --cfg=web_sys_unstable_apis -D warnings

CHANGELOG.md

@@ -41,6 +41,8 @@ Bottom level categories:
 ## Unreleased
 
 ### Major changes
+- Arcanization of wgpu core resources: Removed 'Token' and 'LifeTime' related management,
+removed 'RefCount' and 'MultiRefCount' in favour of using only 'Arc' internal reference count, removing mut from resources and added instead internal members locks on demand or atomics operations, resources now implement Drop and destroy stuff when last 'Arc' resources is released, resources hold an 'Arc' in order to be able to implement Drop, resources have an utility to retrieve the id of the resource itself, removed all guards and just retrive the 'Arc' needed on-demand to unlock registry of resources asap removing locking from hot paths. By @gents83 in [#3626](https://github.com/gfx-rs/wgpu/pull/3626) and tnx also to @jimblandy
 
 #### Pass timestamp queries
 
@@ -197,12 +199,17 @@ By @fornwall in [#3904](https://github.com/gfx-rs/wgpu/pull/3904) and [#3905](ht
 #### Misc Breaking Changes
 
 - Change `AdapterInfo::{device,vendor}` to be `u32` instead of `usize`. By @ameknite in [#3760](https://github.com/gfx-rs/wgpu/pull/3760)
+- Remove the `backend_bits` parameter in `initialize_adapter_from_env` and `initialize_adapter_from_env_or_default` - use [InstanceDescriptor::backends](https://docs.rs/wgpu/latest/wgpu/struct.InstanceDescriptor.html#structfield.backends) instead. By @fornwall in [#3904](https://github.com/gfx-rs/wgpu/pull/3904)
+
+#### DX12
+
+- Increase the `max_storage_buffers_per_shader_stage` and `max_storage_textures_per_shader_stage` limits based on what the hardware supports. by @Elabajaba in [#3798]https://github.com/gfx-rs/wgpu/pull/3798
+- Add a `compatible_surface` parameter to `initialize_adapter_from_env` and use that to make `initialize_adapter_from_env_or_default` always respect its `compatible_surface` parameter. By @fornwall in [#3905](https://github.com/gfx-rs/wgpu/pull/3905)
 
 ### Changes
 
 - Added support for importing external buffers using `buffer_from_raw` (Dx12, Metal, Vulkan) and `create_buffer_from_hal`. By @AdrianEddy in [#3355](https://github.com/gfx-rs/wgpu/pull/3355)
 
-
 #### Vulkan
 
 - Work around [Vulkan-ValidationLayers#5671](https://github.com/KhronosGroup/Vulkan-ValidationLayers/issues/5671) by ignoring reports of violations of [VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912](https://registry.khronos.org/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-vkCmdEndDebugUtilsLabelEXT-commandBuffer-01912). By @jimblandy in [#3809](https://github.com/gfx-rs/wgpu/pull/3809).

deno_webgpu/buffer.rs

@@ -106,7 +106,7 @@ pub async fn op_webgpu_buffer_get_map_async(
                     2 => wgpu_core::device::HostMap::Write,
                     _ => unreachable!(),
                 },
-                callback: wgpu_core::resource::BufferMapCallback::from_rust(callback),
+                callback: Some(wgpu_core::resource::BufferMapCallback::from_rust(callback)),
             }
         ))
         .err();

deno_webgpu/error.rs

@@ -104,9 +104,7 @@ impl From<DeviceError> for WebGpuError {
         match err {
             DeviceError::Lost => WebGpuError::Lost,
             DeviceError::OutOfMemory => WebGpuError::OutOfMemory,
-            DeviceError::ResourceCreationFailed | DeviceError::Invalid => {
-                WebGpuError::Validation(fmt_err(&err))
-            }
+            _ => WebGpuError::Validation(fmt_err(&err)),
         }
     }
 }

deno_webgpu/lib.rs

@@ -656,10 +656,11 @@ pub async fn op_webgpu_request_device(
         limits: required_limits.unwrap_or_default(),
     };
 
-    let (device, maybe_err) = gfx_select!(adapter => instance.adapter_request_device(
+    let (device, _queue, maybe_err) = gfx_select!(adapter => instance.adapter_request_device(
       adapter,
       &descriptor,
       std::env::var("DENO_WEBGPU_TRACE").ok().as_ref().map(std::path::Path::new),
+      (),
       ()
     ));
     if let Some(err) = maybe_err {

player/src/bin/play.rs

@@ -49,7 +49,7 @@ fn main() {
         IdentityPassThroughFactory,
         wgt::InstanceDescriptor::default(),
     );
-    let mut command_buffer_id_manager = wgc::identity::IdentityManager::default();
+    let mut command_buffer_id_manager = wgc::identity::IdentityManager::new();
 
     #[cfg(feature = "winit")]
     let surface = global.instance_create_surface(
@@ -81,10 +81,11 @@ fn main() {
             let info = gfx_select!(adapter => global.adapter_get_info(adapter)).unwrap();
             log::info!("Picked '{}'", info.name);
             let id = wgc::id::TypedId::zip(1, 0, backend);
-            let (_, error) = gfx_select!(adapter => global.adapter_request_device(
+            let (_, _, error) = gfx_select!(adapter => global.adapter_request_device(
                 adapter,
                 &desc,
                 None,
+                id,
                 id
             ));
             if let Some(e) = error {

player/src/lib.rs

@@ -10,37 +10,22 @@
 
 use wgc::device::trace;
 
-use std::{borrow::Cow, fmt::Debug, fs, marker::PhantomData, path::Path};
+use std::{borrow::Cow, fs, path::Path};
 
-#[derive(Debug)]
-pub struct IdentityPassThrough<I>(PhantomData<I>);
+pub struct IdentityPassThroughFactory;
 
-impl<I: Clone + Debug + wgc::id::TypedId> wgc::identity::IdentityHandler<I>
-    for IdentityPassThrough<I>
-{
+impl<I: wgc::id::TypedId> wgc::identity::IdentityHandlerFactory<I> for IdentityPassThroughFactory {
     type Input = I;
-    fn process(&self, id: I, backend: wgt::Backend) -> I {
-        let (index, epoch, _backend) = id.unzip();
-        I::zip(index, epoch, backend)
-    }
-    fn free(&self, _id: I) {}
-}
 
-pub struct IdentityPassThroughFactory;
-
-impl<I: Clone + Debug + wgc::id::TypedId> wgc::identity::IdentityHandlerFactory<I>
-    for IdentityPassThroughFactory
-{
-    type Filter = IdentityPassThrough<I>;
-    fn spawn(&self) -> Self::Filter {
-        IdentityPassThrough(PhantomData)
+    fn input_to_id(id_in: Self::Input) -> I {
+        id_in
     }
-}
-impl wgc::identity::GlobalIdentityHandlerFactory for IdentityPassThroughFactory {
-    fn ids_are_generated_in_wgpu() -> bool {
+
+    fn autogenerate_ids() -> bool {
         false
     }
 }
+impl wgc::identity::GlobalIdentityHandlerFactory for IdentityPassThroughFactory {}
 
 pub trait GlobalPlay {
     fn encode_commands<A: wgc::hal_api::HalApi>(
@@ -53,7 +38,7 @@ pub trait GlobalPlay {
         device: wgc::id::DeviceId,
         action: trace::Action,
         dir: &Path,
-        comb_manager: &mut wgc::identity::IdentityManager,
+        comb_manager: &mut wgc::identity::IdentityManager<wgc::id::CommandBufferId>,
     );
 }
 
@@ -168,10 +153,10 @@ impl GlobalPlay for wgc::global::Global<IdentityPassThroughFactory> {
         device: wgc::id::DeviceId,
         action: trace::Action,
         dir: &Path,
-        comb_manager: &mut wgc::identity::IdentityManager,
+        comb_manager: &mut wgc::identity::IdentityManager<wgc::id::CommandBufferId>,
     ) {
         use wgc::device::trace::Action;
-        log::info!("action {:?}", action);
+        log::debug!("action {:?}", action);
         //TODO: find a way to force ID perishing without excessive `maintain()` calls.
         match action {
             Action::Init { .. } => {
@@ -269,7 +254,7 @@ impl GlobalPlay for wgc::global::Global<IdentityPassThroughFactory> {
                 self.bind_group_drop::<A>(id);
             }
             Action::CreateShaderModule { id, desc, data } => {
-                log::info!("Creating shader from {}", data);
+                log::debug!("Creating shader from {}", data);
                 let code = fs::read_to_string(dir.join(&data)).unwrap();
                 let source = if data.ends_with(".wgsl") {
                     wgc::pipeline::ShaderModuleSource::Wgsl(Cow::Owned(code.clone()))
@@ -390,7 +375,7 @@ impl GlobalPlay for wgc::global::Global<IdentityPassThroughFactory> {
                 let (encoder, error) = self.device_create_command_encoder::<A>(
                     device,
                     &wgt::CommandEncoderDescriptor { label: None },
-                    comb_manager.alloc(device.backend()),
+                    comb_manager.process(device.backend()),
                 );
                 if let Some(e) = error {
                     panic!("{e}");

player/tests/data/zero-init-texture-binding.ron

@@ -56,7 +56,7 @@
             format: "rgba8unorm",
             usage: 9, // STORAGE + COPY_SRC
             view_formats: [],
-        )),
+        )),        
         CreateTextureView(
             id: Id(1, 1, Empty),
             parent_id: Id(1, 1, Empty),

player/tests/test.rs

@@ -84,50 +84,51 @@ impl Test<'_> {
         test_num: u32,
     ) {
         let backend = adapter.backend();
-        let device = wgc::id::TypedId::zip(test_num, 0, backend);
-        let (_, error) = wgc::gfx_select!(adapter => global.adapter_request_device(
+        let device_id = wgc::id::TypedId::zip(test_num, 0, backend);
+        let (_, _, error) = wgc::gfx_select!(adapter => global.adapter_request_device(
             adapter,
             &wgt::DeviceDescriptor {
                 label: None,
                 features: self.features,
                 limits: wgt::Limits::default(),
             },
             None,
-            device
+            device_id,
+            device_id
         ));
         if let Some(e) = error {
             panic!("{:?}", e);
         }
 
-        let mut command_buffer_id_manager = wgc::identity::IdentityManager::default();
+        let mut command_buffer_id_manager = wgc::identity::IdentityManager::new();
         println!("\t\t\tRunning...");
         for action in self.actions {
-            wgc::gfx_select!(device => global.process(device, action, dir, &mut command_buffer_id_manager));
+            wgc::gfx_select!(device_id => global.process(device_id, action, dir, &mut command_buffer_id_manager));
         }
         println!("\t\t\tMapping...");
         for expect in &self.expectations {
             let buffer = wgc::id::TypedId::zip(expect.buffer.index, expect.buffer.epoch, backend);
-            wgc::gfx_select!(device => global.buffer_map_async(
+            wgc::gfx_select!(device_id => global.buffer_map_async(
                 buffer,
                 expect.offset .. expect.offset+expect.data.len() as wgt::BufferAddress,
                 wgc::resource::BufferMapOperation {
                     host: wgc::device::HostMap::Read,
-                    callback: wgc::resource::BufferMapCallback::from_rust(
+                    callback: Some(wgc::resource::BufferMapCallback::from_rust(
                         Box::new(map_callback)
-                    ),
+                    )),
                 }
             ))
             .unwrap();
         }
 
         println!("\t\t\tWaiting...");
-        wgc::gfx_select!(device => global.device_poll(device, wgt::Maintain::Wait)).unwrap();
+        wgc::gfx_select!(device_id => global.device_poll(device_id, wgt::Maintain::Wait)).unwrap();
 
         for expect in self.expectations {
             println!("\t\t\tChecking {}", expect.name);
             let buffer = wgc::id::TypedId::zip(expect.buffer.index, expect.buffer.epoch, backend);
             let (ptr, size) =
-                wgc::gfx_select!(device => global.buffer_get_mapped_range(buffer, expect.offset, Some(expect.data.len() as wgt::BufferAddress)))
+                wgc::gfx_select!(device_id => global.buffer_get_mapped_range(buffer, expect.offset, Some(expect.data.len() as wgt::BufferAddress)))
                     .unwrap();
             let contents = unsafe { slice::from_raw_parts(ptr, size as usize) };
             let expected_data = match expect.data {
@@ -155,7 +156,7 @@ impl Test<'_> {
             }
         }
 
-        wgc::gfx_select!(device => global.clear_backend(()));
+        wgc::gfx_select!(device_id => global.clear_backend(()));
     }
 }
 

tests/Cargo.toml

@@ -32,6 +32,7 @@ wgt.workspace = true
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
 nv-flip.workspace = true
+parking_lot = { workspace = true, features = ["deadlock_detection"] }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
 console_log.workspace = true