Record 1 barrier for N Queue::write_buffer/texture calls by deferring to submit time (#10319)

This commit is contained in:
JMS55 authored and GitHub committed 2026-10-25 11:57:55 +00:00
1 parent 63e505290e
commit 2edafa5240
3 files changed
+151 -36

No files matched your search

+1
View File
@@ -312,6 +312,7 @@ By @sagudev in [#10307](https://github.com/gfx-rs/wgpu/pull/10307).
### Performance
- Added explicit `Send` and `Sync` implementations to key `wgpu` types so that the compiler can do less work checking those bounds. If you previously added a `#![recursion_limit = ...]` attribute to your crate due to overflow errors involving `wgpu` types, you may now be able to remove it. By @kpreid in [#10177](https://github.com/gfx-rs/wgpu/pull/10177).
- `Queue::write_buffer`, `Queue::write_texture` and buffer unmaps no longer record a separate barrier before each copy. The transitions for a whole batch of queue writes are now coalesced into a single barrier recorded ahead of the batch's copies, so a frame that updates N buffers costs one barrier instead of N. By @JMS55 in [#10319](https://github.com/gfx-rs/wgpu/pull/10319).
### Documentation
+146 -28
View File
@@ -2,7 +2,6 @@
use alloc::string::ToString as _;
use alloc::{boxed::Box, string::String, sync::Arc, vec, vec::Vec};
use core::{
iter,
mem::{self, ManuallyDrop},
num::NonZeroU64,
ptr::NonNull,
@@ -397,6 +396,39 @@ pub(crate) struct PendingWrites {
dst_textures: FastHashMap<TrackerIndex, Arc<Texture>>,
copied_blas_s: FastHashMap<TrackerIndex, Arc<Blas>>,
instance_flags: wgt::InstanceFlags,
/// Staging buffers that are the source of a copy recorded in
/// `command_encoder`, and so need a `MAP_WRITE` -> `COPY_SRC` transition.
///
/// See [`hoisted_buffer_barriers`] for why these are not recorded
/// immediately. Moved to `temp_resources` in [`pre_submit`].
///
/// [`hoisted_buffer_barriers`]: PendingWrites::hoisted_buffer_barriers
/// [`pre_submit`]: PendingWrites::pre_submit
hoisted_staging_buffers: Vec<FlushedStagingBuffer>,
/// Buffer transitions that must happen before the copies recorded in
/// `command_encoder`.
///
/// Recording a barrier immediately before each copy means that a frame
/// which calls `Queue::write_buffer` a few dozen times ends up with many
/// back-to-back barrier/copy pairs, when a single barrier covering every
/// buffer would have done just as well.
///
/// Instead we accumulate the transitions here and record them all at once,
/// into a command buffer that [`pre_submit`] places in front of
/// `command_encoder`'s.
///
/// Only a buffer's *first* transition in a batch may be hoisted like this.
/// A buffer written more than once per batch gets a second, `COPY_DST` ->
/// `COPY_DST` transition from the tracker (unless the adapter reports
/// `COPY_DST` as an ordered usage), and that barrier exists precisely to
/// separate the two copies, so it has to stay where it was recorded. See
/// [`hoist_buffer_barrier`].
///
/// [`pre_submit`]: PendingWrites::pre_submit
/// [`hoist_buffer_barrier`]: PendingWrites::hoist_buffer_barrier
hoisted_buffer_barriers: Vec<(Arc<Buffer>, hal::StateTransition<wgt::BufferUses>)>,
}
impl PendingWrites {
@@ -412,6 +444,8 @@ impl PendingWrites {
dst_textures: FastHashMap::default(),
copied_blas_s: FastHashMap::default(),
instance_flags,
hoisted_staging_buffers: Vec::new(),
hoisted_buffer_barriers: Vec::new(),
}
}
@@ -442,9 +476,45 @@ impl PendingWrites {
self.temp_resources.push(resource);
}
/// Take ownership of a staging buffer that is the source of a copy
/// recorded into this batch.
///
/// This also queues up the staging buffer's `MAP_WRITE` -> `COPY_SRC`
/// transition, so callers must not record one themselves.
pub fn consume(&mut self, buffer: FlushedStagingBuffer) {
self.temp_resources
.push(TempResource::StagingBuffer(buffer));
self.hoisted_staging_buffers.push(buffer);
}
/// Queue up a buffer transition to be recorded ahead of this batch's
/// copies.
///
/// Returns the transition instead if it cannot be hoisted, in which case
/// the caller must record it immediately, before its own copy. This happens
/// when this batch has already copied into `buffer`: the transition is then
/// a `COPY_DST` -> `COPY_DST` write-after-write barrier separating the
/// earlier copy from the caller's, as hoisting it to the front of the
/// batch would leave the two copies unsynchronized.
///
/// See [`hoisted_buffer_barriers`].
///
/// [`hoisted_buffer_barriers`]: PendingWrites::hoisted_buffer_barriers
#[must_use]
fn hoist_buffer_barrier(
&mut self,
buffer: &Arc<Buffer>,
transition: Option<track::PendingTransition<wgt::BufferUses>>,
) -> Option<track::PendingTransition<wgt::BufferUses>> {
let transition = transition?;
// `dst_buffers` is only populated once a copy has been recorded, so
// true here means an earlier copy in this batch already wrote `buffer`.
if self.dst_buffers.contains_key(&buffer.tracker_index()) {
return Some(transition);
}
self.hoisted_buffer_barriers
.push((buffer.clone(), transition.usage));
None
}
pub fn clear_buffer(
@@ -454,19 +524,21 @@ impl PendingWrites {
range: core::ops::Range<wgt::BufferAddress>,
snatch_guard: &SnatchGuard,
) -> Result<(), QueueWriteError> {
let barriers = {
let transition = {
let mut trackers = device.trackers.lock();
trackers
.buffers
.set_single(buffer, wgt::BufferUses::COPY_DST)
.map(|pending| pending.into_hal(buffer, snatch_guard))
};
let inline_transition = self.hoist_buffer_barrier(buffer, transition);
let dst_raw = buffer.try_raw(snatch_guard)?;
let encoder = self.activate();
unsafe {
encoder.transition_buffers(barriers.as_slice());
if let Some(transition) = inline_transition {
encoder.transition_buffers(&[transition.into_hal(buffer, snatch_guard)]);
}
encoder.clear_buffer(dst_raw, range.clone());
}
@@ -479,11 +551,56 @@ impl PendingWrites {
Ok(())
}
/// Record every transition this batch of writes needs as a single barrier,
/// into a command buffer placed ahead of the one holding the batch's
/// copies.
///
/// Returns the staging buffers whose transitions were recorded. The caller
/// is responsible for keeping them alive until the submission completes.
fn record_hoisted_barriers(
&mut self,
encoder: &mut EncoderInFlight,
snatch_guard: &SnatchGuard,
) -> Result<Vec<FlushedStagingBuffer>, DeviceError> {
let staging_buffers = mem::take(&mut self.hoisted_staging_buffers);
let buffer_barriers = mem::take(&mut self.hoisted_buffer_barriers);
let barriers = staging_buffers
.iter()
.map(|staging_buffer| hal::BufferBarrier {
buffer: staging_buffer.raw(),
usage: hal::StateTransition {
from: wgt::BufferUses::MAP_WRITE,
to: wgt::BufferUses::COPY_SRC,
},
})
.chain(buffer_barriers.iter().filter_map(|(buffer, usage)| {
// The buffer may have been destroyed since the copy was
// recorded, in which case there is nothing to sync.
Some(hal::BufferBarrier {
buffer: buffer.raw(snatch_guard)?,
usage: usage.clone(),
})
}))
.collect::<Vec<_>>();
if !barriers.is_empty() {
encoder
.inner
.open_pass(Some("(wgpu internal) PendingWrites Transit"))?;
unsafe { encoder.inner.raw.transition_buffers(&barriers) };
encoder.inner.close_and_push_front()?;
}
Ok(staging_buffers)
}
fn pre_submit(
&mut self,
command_allocator: &CommandAllocator,
device: &Arc<Device>,
queue: &Queue,
snatch_guard: &SnatchGuard,
) -> Result<Option<EncoderInFlight>, DeviceError> {
if self.is_recording {
let pending_buffers = mem::take(&mut self.dst_buffers);
@@ -498,7 +615,7 @@ impl PendingWrites {
.acquire_encoder(device.raw(), queue.raw())
.map_err(|e| device.handle_hal_error(e))?;
let encoder = EncoderInFlight {
let mut encoder = EncoderInFlight {
inner: crate::command::InnerCommandEncoder {
raw: ManuallyDrop::new(mem::replace(&mut self.command_encoder, new_encoder)),
list: vec![cmd_buf],
@@ -516,6 +633,12 @@ impl PendingWrites {
pending_textures,
pending_blas_s,
};
let staging_buffers = self.record_hoisted_barriers(&mut encoder, snatch_guard)?;
encoder
.temp_resources
.extend(staging_buffers.into_iter().map(TempResource::StagingBuffer));
Ok(Some(encoder))
} else {
self.dst_buffers.clear();
@@ -934,18 +1057,14 @@ impl Queue {
dst_offset: buffer_offset,
size: staging_buffer.size,
};
let barriers = iter::once(hal::BufferBarrier {
buffer: staging_buffer.raw(),
usage: hal::StateTransition {
from: wgt::BufferUses::MAP_WRITE,
to: wgt::BufferUses::COPY_SRC,
},
})
.chain(transition.map(|pending| pending.into_hal(&buffer, snatch_guard)))
.collect::<Vec<_>>();
// The staging buffer's own `MAP_WRITE` -> `COPY_SRC` transition is
// hoisted by `PendingWrites::consume`, which our caller invokes.
let inline_transition = pending_writes.hoist_buffer_barrier(&buffer, transition);
let encoder = pending_writes.activate();
unsafe {
encoder.transition_buffers(&barriers);
if let Some(transition) = inline_transition {
encoder.transition_buffers(&[transition.into_hal(&buffer, snatch_guard)]);
}
encoder.copy_buffer_to_buffer(staging_buffer.raw(), dst_raw, &[region]);
}
@@ -1186,14 +1305,6 @@ impl Queue {
.collect::<Vec<_>>();
{
let buffer_barrier = hal::BufferBarrier {
buffer: staging_buffer.raw(),
usage: hal::StateTransition {
from: wgt::BufferUses::MAP_WRITE,
to: wgt::BufferUses::COPY_SRC,
},
};
let mut trackers = self.device.trackers.lock();
let transition =
trackers
@@ -1203,9 +1314,11 @@ impl Queue {
.map(|pending| pending.into_hal(dst_raw))
.collect::<Vec<_>>();
// The staging buffer's `MAP_WRITE` -> `COPY_SRC` transition is
// hoisted to the front of the batch by `PendingWrites::consume`,
// below.
unsafe {
encoder.transition_textures(&texture_barriers);
encoder.transition_buffers(&[buffer_barrier]);
encoder.copy_buffer_to_texture(staging_buffer.raw(), dst_raw, &regions);
}
}
@@ -1437,7 +1550,7 @@ impl Queue {
source,
dst_raw_webgl,
premultiplied_alpha,
iter::once(regions),
core::iter::once(regions),
);
}
@@ -1906,7 +2019,12 @@ impl Queue {
};
}
match pending_writes.pre_submit(&self.device.command_allocator, &self.device, self) {
match pending_writes.pre_submit(
&self.device.command_allocator,
&self.device,
self,
&snatch_guard,
) {
Ok(Some(pending_execution)) => {
executions.insert(0, pending_execution);
}
+4 -8
View File
@@ -1178,13 +1178,9 @@ impl Buffer {
dst_offset: 0,
size: staging_buffer.size,
});
let transition_src = hal::BufferBarrier {
buffer: staging_buffer.raw(),
usage: hal::StateTransition {
from: wgt::BufferUses::MAP_WRITE,
to: wgt::BufferUses::COPY_SRC,
},
};
// The staging buffer's `MAP_WRITE` -> `COPY_SRC` transition
// is hoisted to the front of the batch by
// `PendingWrites::consume`, below.
let transition_dst = hal::BufferBarrier::<dyn hal::DynBuffer> {
buffer: raw_buf,
usage: hal::StateTransition {
@@ -1195,7 +1191,7 @@ impl Buffer {
let mut pending_writes = queue.pending_writes.lock();
let encoder = pending_writes.activate();
unsafe {
encoder.transition_buffers(&[transition_src, transition_dst]);
encoder.transition_buffers(&[transition_dst]);
// Buffers allocate at least `COPY_BUFFER_ALIGNMENT` bytes, so
// there's always something to copy here.
encoder.copy_buffer_to_buffer(