[core] fix missing applies of DISCARD_HAL_LABELS (gfx-rs#7991)

Author: uael

wgpu-core/src/command/clear.rs

@@ -9,6 +9,7 @@ use crate::{
     device::{DeviceError, MissingFeatures},
     get_lowest_common_denom,
     global::Global,
+    hal_label,
     id::{BufferId, CommandEncoderId, TextureId},
     init_tracker::{MemoryInitKind, TextureInitRange},
     resource::{
@@ -272,6 +273,7 @@ impl Global {
                 &device.alignments,
                 device.zero_buffer.as_ref(),
                 &snatch_guard,
+                device.instance_flags,
             )?;
 
             Ok(())
@@ -287,6 +289,7 @@ pub(crate) fn clear_texture<T: TextureTrackerSetSingle>(
     alignments: &hal::Alignments,
     zero_buffer: &dyn hal::DynBuffer,
     snatch_guard: &SnatchGuard<'_>,
+    instance_flags: wgt::InstanceFlags,
 ) -> Result<(), ClearError> {
     let dst_raw = dst_texture.try_raw(snatch_guard)?;
 
@@ -345,11 +348,11 @@ pub(crate) fn clear_texture<T: TextureTrackerSetSingle>(
         ),
         TextureClearMode::Surface { .. } => {
             drop(clear_mode);
-            clear_texture_via_render_passes(dst_texture, range, true, encoder)?
+            clear_texture_via_render_passes(dst_texture, range, true, encoder, instance_flags)?
         }
         TextureClearMode::RenderPass { is_color, .. } => {
             drop(clear_mode);
-            clear_texture_via_render_passes(dst_texture, range, is_color, encoder)?
+            clear_texture_via_render_passes(dst_texture, range, is_color, encoder, instance_flags)?
         }
         TextureClearMode::None => {
             return Err(ClearError::NoValidTextureClearMode(
@@ -459,6 +462,7 @@ fn clear_texture_via_render_passes(
     range: TextureInitRange,
     is_color: bool,
     encoder: &mut dyn hal::DynCommandEncoder,
+    instance_flags: wgt::InstanceFlags,
 ) -> Result<(), ClearError> {
     assert_eq!(dst_texture.desc.dimension, wgt::TextureDimension::D2);
 
@@ -513,7 +517,10 @@ fn clear_texture_via_render_passes(
             unsafe {
                 encoder
                     .begin_render_pass(&hal::RenderPassDescriptor {
-                        label: Some("(wgpu internal) clear_texture clear pass"),
+                        label: hal_label(
+                            Some("(wgpu internal) clear_texture clear pass"),
+                            instance_flags,
+                        ),
                         extent,
                         sample_count: dst_texture.desc.sample_count,
                         color_attachments,

wgpu-core/src/command/compute.rs

@@ -756,7 +756,10 @@ impl Global {
             //
             // Use that buffer to insert barriers and clear discarded images.
             let transit = encoder
-                .open_pass(Some("(wgpu internal) Pre Pass"))
+                .open_pass(hal_label(
+                    Some("(wgpu internal) Pre Pass"),
+                    self.instance.flags,
+                ))
                 .map_pass_err(pass_scope)?;
             fixup_discarded_surfaces(
                 pending_discard_init_fixups.into_iter(),

wgpu-core/src/command/memory_init.rs

@@ -149,6 +149,7 @@ pub(crate) fn fixup_discarded_surfaces<InitIter: Iterator<Item = TextureSurfaceD
             &device.alignments,
             device.zero_buffer.as_ref(),
             snatch_guard,
+            device.instance_flags,
         )
         .unwrap();
     }
@@ -304,6 +305,7 @@ impl BakedCommands {
                     &device.alignments,
                     device.zero_buffer.as_ref(),
                     snatch_guard,
+                    device.instance_flags,
                 );
 
                 // A Texture can be destroyed between the command recording

wgpu-core/src/command/mod.rs

@@ -565,7 +565,7 @@ impl InnerCommandEncoder {
     pub(crate) fn open(&mut self) -> Result<&mut dyn hal::DynCommandEncoder, DeviceError> {
         if !self.is_open {
             self.is_open = true;
-            let hal_label = hal_label(Some(&self.label), self.device.instance_flags);
+            let hal_label = hal_label(Some(self.label.as_str()), self.device.instance_flags);
             unsafe { self.raw.begin_encoding(hal_label) }
                 .map_err(|e| self.device.handle_hal_error(e))?;
         }

wgpu-core/src/command/render.rs

@@ -1457,6 +1457,7 @@ impl RenderPassInfo {
         raw: &mut dyn hal::DynCommandEncoder,
         snatch_guard: &SnatchGuard,
         scope: &mut UsageScope<'_>,
+        instance_flags: wgt::InstanceFlags,
     ) -> Result<(), RenderPassErrorInner> {
         profiling::scope!("RenderPassInfo::finish");
         unsafe {
@@ -1497,7 +1498,10 @@ impl RenderPassInfo {
                 )
             };
             let desc = hal::RenderPassDescriptor::<'_, _, dyn hal::DynTextureView> {
-                label: Some("(wgpu internal) Zero init discarded depth/stencil aspect"),
+                label: hal_label(
+                    Some("(wgpu internal) Zero init discarded depth/stencil aspect"),
+                    instance_flags,
+                ),
                 extent: view.render_extent.unwrap(),
                 sample_count: view.samples,
                 color_attachments: &[],
@@ -2201,6 +2205,7 @@ impl Global {
                         state.general.raw_encoder,
                         state.general.snatch_guard,
                         &mut state.general.scope,
+                        self.instance.flags,
                     )
                     .map_pass_err(pass_scope)?;
 
@@ -2217,7 +2222,10 @@ impl Global {
 
             {
                 let transit = encoder
-                    .open_pass(Some("(wgpu internal) Pre Pass"))
+                    .open_pass(hal_label(
+                        Some("(wgpu internal) Pre Pass"),
+                        self.instance.flags,
+                    ))
                     .map_pass_err(pass_scope)?;
 
                 fixup_discarded_surfaces(

wgpu-core/src/command/transfer.rs

@@ -618,6 +618,7 @@ fn handle_texture_init(
                 &device.alignments,
                 device.zero_buffer.as_ref(),
                 snatch_guard,
+                device.instance_flags,
             )?;
         }
     }

wgpu-core/src/device/queue.rs

@@ -27,6 +27,7 @@ use crate::{
     device::{DeviceError, WaitIdleError},
     get_lowest_common_denom,
     global::Global,
+    hal_label,
     id::{self, BlasId, QueueId},
     init_tracker::{has_copy_partial_init_tracker_coverage, TextureInitRange},
     lock::{rank, Mutex, MutexGuard, RwLock, RwLockWriteGuard},
@@ -57,6 +58,7 @@ impl Queue {
     pub(crate) fn new(
         device: Arc<Device>,
         raw: Box<dyn hal::DynQueue>,
+        instance_flags: wgt::InstanceFlags,
     ) -> Result<Self, DeviceError> {
         let pending_encoder = device
             .command_allocator
@@ -70,7 +72,7 @@ impl Queue {
             }
         };
 
-        let mut pending_writes = PendingWrites::new(pending_encoder);
+        let mut pending_writes = PendingWrites::new(pending_encoder, instance_flags);
 
         let zero_buffer = device.zero_buffer.as_ref();
         pending_writes.activate();
@@ -328,17 +330,22 @@ pub(crate) struct PendingWrites {
     dst_buffers: FastHashMap<TrackerIndex, Arc<Buffer>>,
     dst_textures: FastHashMap<TrackerIndex, Arc<Texture>>,
     copied_blas_s: FastHashMap<TrackerIndex, Arc<Blas>>,
+    instance_flags: wgt::InstanceFlags,
 }
 
 impl PendingWrites {
-    pub fn new(command_encoder: Box<dyn hal::DynCommandEncoder>) -> Self {
+    pub fn new(
+        command_encoder: Box<dyn hal::DynCommandEncoder>,
+        instance_flags: wgt::InstanceFlags,
+    ) -> Self {
         Self {
             command_encoder,
             is_recording: false,
             temp_resources: Vec::new(),
             dst_buffers: FastHashMap::default(),
             dst_textures: FastHashMap::default(),
             copied_blas_s: FastHashMap::default(),
+            instance_flags,
         }
     }
 
@@ -423,7 +430,10 @@ impl PendingWrites {
         if !self.is_recording {
             unsafe {
                 self.command_encoder
-                    .begin_encoding(Some("(wgpu internal) PendingWrites"))
+                    .begin_encoding(hal_label(
+                        Some("(wgpu internal) PendingWrites"),
+                        self.instance_flags,
+                    ))
                     .unwrap();
             }
             self.is_recording = true;
@@ -816,6 +826,7 @@ impl Queue {
                         &self.device.alignments,
                         self.device.zero_buffer.as_ref(),
                         &snatch_guard,
+                        self.device.instance_flags,
                     )
                     .map_err(QueueWriteError::from)?;
                 }
@@ -1068,6 +1079,7 @@ impl Queue {
                         &self.device.alignments,
                         self.device.zero_buffer.as_ref(),
                         &self.device.snatchable_lock.read(),
+                        self.device.instance_flags,
                     )
                     .map_err(QueueWriteError::from)?;
                 }
@@ -1221,7 +1233,10 @@ impl Queue {
                         };
 
                         // execute resource transitions
-                        if let Err(e) = baked.encoder.open_pass(Some("(wgpu internal) Transit")) {
+                        if let Err(e) = baked.encoder.open_pass(hal_label(
+                            Some("(wgpu internal) Transit"),
+                            self.device.instance_flags,
+                        )) {
                             break 'error Err(e.into());
                         }
 
@@ -1256,8 +1271,10 @@ impl Queue {
                         // Note: we could technically do it after all of the command buffers,
                         // but here we have a command encoder by hand, so it's easier to use it.
                         if !used_surface_textures.is_empty() {
-                            if let Err(e) = baked.encoder.open_pass(Some("(wgpu internal) Present"))
-                            {
+                            if let Err(e) = baked.encoder.open_pass(hal_label(
+                                Some("(wgpu internal) Present"),
+                                self.device.instance_flags,
+                            )) {
                                 break 'error Err(e.into());
                             }
                             let texture_barriers = trackers

wgpu-core/src/device/ray_tracing.rs

@@ -8,6 +8,7 @@ use crate::{
     api_log,
     device::Device,
     global::Global,
+    hal_label,
     id::{self, BlasId, TlasId},
     lock::RwLock,
     lock::{rank, Mutex},
@@ -231,7 +232,7 @@ impl Device {
             self.alignments.raw_tlas_instance_size * desc.max_instances.max(1) as usize;
         let instance_buffer = unsafe {
             self.raw().create_buffer(&hal::BufferDescriptor {
-                label: Some("(wgpu-core) instances_buffer"),
+                label: hal_label(Some("(wgpu-core) instances_buffer"), self.instance_flags),
                 size: instance_buffer_size as u64,
                 usage: wgt::BufferUses::COPY_DST
                     | wgt::BufferUses::TOP_LEVEL_ACCELERATION_STRUCTURE_INPUT,

wgpu-core/src/instance.rs

@@ -776,7 +776,7 @@ impl Adapter {
         let device = Device::new(hal_device.device, self, desc, instance_flags)?;
         let device = Arc::new(device);
 
-        let queue = Queue::new(device.clone(), hal_device.queue)?;
+        let queue = Queue::new(device.clone(), hal_device.queue, instance_flags)?;
         let queue = Arc::new(queue);
 
         device.set_queue(&queue);

wgpu-core/src/lib.rs

@@ -141,7 +141,7 @@ impl<'a> LabelHelpers<'a> for Label<'a> {
     }
 }
 
-pub fn hal_label(opt: Option<&str>, flags: wgt::InstanceFlags) -> Option<&str> {
+pub fn hal_label<T: AsRef<str>>(opt: Option<T>, flags: wgt::InstanceFlags) -> Option<T> {
     if flags.contains(wgt::InstanceFlags::DISCARD_HAL_LABELS) {
         return None;
     }