fixup! fix(core): use BufferMapState::Active for any BufferUsages::MAP_* flags

Author: ErichDonGubler

wgpu-core/src/device/global.rs

@@ -2346,18 +2346,6 @@ impl Global {
         }
         let map_state = &*buffer.map_state.lock();
         match *map_state {
-            resource::BufferMapState::Init { ref staging_buffer } => {
-                // offset (u64) can not be < 0, so no need to validate the lower bound
-                if offset + range_size > buffer.size {
-                    return Err(BufferAccessError::OutOfBoundsOverrun {
-                        index: offset + range_size - 1,
-                        max: buffer.size,
-                    });
-                }
-                let ptr = unsafe { staging_buffer.ptr() };
-                let ptr = unsafe { NonNull::new_unchecked(ptr.as_ptr().offset(offset as isize)) };
-                Ok((ptr, range_size))
-            }
             resource::BufferMapState::Active {
                 ref mapping,
                 ref range,

wgpu-core/src/device/resource.rs

@@ -988,12 +988,7 @@ impl Device {
 
         let buffer = Arc::new(buffer);
 
-        let buffer_use = if !desc.mapped_at_creation {
-            wgt::BufferUses::empty()
-        } else if desc
-            .usage
-            .intersects(wgt::BufferUsages::MAP_WRITE | wgt::BufferUsages::MAP_READ)
-        {
+        let buffer_use = if desc.mapped_at_creation {
             // buffer is mappable, so we are just doing that at start
             let map_size = buffer.size;
             let mapping = if map_size == 0 {
@@ -1012,16 +1007,7 @@ impl Device {
             };
             wgt::BufferUses::MAP_WRITE
         } else {
-            let mut staging_buffer =
-                StagingBuffer::new(self, wgt::BufferSize::new(aligned_size).unwrap())?;
-
-            // Zero initialize memory and then mark the buffer as initialized
-            // (it's guaranteed that this is the case by the time the buffer is usable)
-            staging_buffer.write_zeros();
-            buffer.initialization_status.write().drain(0..aligned_size);
-
-            *buffer.map_state.lock() = resource::BufferMapState::Init { staging_buffer };
-            wgt::BufferUses::COPY_DST
+            wgt::BufferUses::empty()
         };
 
         self.trackers

wgpu-core/src/resource.rs

@@ -216,8 +216,6 @@ macro_rules! impl_trackable {
 
 #[derive(Debug)]
 pub(crate) enum BufferMapState {
-    /// Mapped at creation.
-    Init { staging_buffer: StagingBuffer },
     /// Waiting for GPU to be done before mapping
     Waiting(BufferPendingMapping),
     /// Mapped
@@ -641,7 +639,7 @@ impl Buffer {
         {
             let map_state = &mut *self.map_state.lock();
             *map_state = match *map_state {
-                BufferMapState::Init { .. } | BufferMapState::Active { .. } => {
+                BufferMapState::Active { .. } => {
                     return Err((op, BufferAccessError::AlreadyMapped));
                 }
                 BufferMapState::Waiting(_) => {
@@ -694,7 +692,6 @@ impl Buffer {
                 *self.map_state.lock() = mapping;
                 return None;
             }
-            _ => panic!("No pending mapping."),
         };
         let status = if pending_mapping.range.start != pending_mapping.range.end {
             let host = pending_mapping.op.host;
@@ -755,56 +752,6 @@ impl Buffer {
         let snatch_guard = device.snatchable_lock.read();
         let raw_buf = self.try_raw(&snatch_guard)?;
         match mem::replace(&mut *self.map_state.lock(), BufferMapState::Idle) {
-            BufferMapState::Init { staging_buffer } => {
-                #[cfg(feature = "trace")]
-                if let Some(ref mut trace) = *device.trace.lock() {
-                    let data = trace.make_binary("bin", staging_buffer.get_data());
-                    trace.add(trace::Action::WriteBuffer {
-                        id: buffer_id,
-                        data,
-                        range: 0..self.size,
-                        queued: true,
-                    });
-                }
-
-                let staging_buffer = staging_buffer.flush();
-
-                if let Some(queue) = device.get_queue() {
-                    let region = wgt::BufferSize::new(self.size).map(|size| hal::BufferCopy {
-                        src_offset: 0,
-                        dst_offset: 0,
-                        size,
-                    });
-                    let transition_src = hal::BufferBarrier {
-                        buffer: staging_buffer.raw(),
-                        usage: hal::StateTransition {
-                            from: wgt::BufferUses::MAP_WRITE,
-                            to: wgt::BufferUses::COPY_SRC,
-                        },
-                    };
-                    let transition_dst = hal::BufferBarrier::<dyn hal::DynBuffer> {
-                        buffer: raw_buf,
-                        usage: hal::StateTransition {
-                            from: wgt::BufferUses::empty(),
-                            to: wgt::BufferUses::COPY_DST,
-                        },
-                    };
-                    let mut pending_writes = queue.pending_writes.lock();
-                    let encoder = pending_writes.activate();
-                    unsafe {
-                        encoder.transition_buffers(&[transition_src, transition_dst]);
-                        if self.size > 0 {
-                            encoder.copy_buffer_to_buffer(
-                                staging_buffer.raw(),
-                                raw_buf,
-                                region.as_slice(),
-                            );
-                        }
-                    }
-                    pending_writes.consume(staging_buffer);
-                    pending_writes.insert_buffer(self);
-                }
-            }
             BufferMapState::Idle => {
                 return Err(BufferAccessError::NotMapped);
             }
@@ -1049,15 +996,6 @@ impl StagingBuffer {
         self.ptr
     }
 
-    #[cfg(feature = "trace")]
-    pub(crate) fn get_data(&self) -> &[u8] {
-        unsafe { core::slice::from_raw_parts(self.ptr.as_ptr(), self.size.get() as usize) }
-    }
-
-    pub(crate) fn write_zeros(&mut self) {
-        unsafe { core::ptr::write_bytes(self.ptr.as_ptr(), 0, self.size.get() as usize) };
-    }
-
     pub(crate) fn write(&mut self, data: &[u8]) {
         assert!(data.len() >= self.size.get() as usize);
         // SAFETY: With the assert above, all of `copy_nonoverlapping`'s