[core] Move validity into Arc<Blas> (#9800)

Signed-off-by: sagudev <16504129+sagudev@users.noreply.github.com>
This commit is contained in:
Sam authored and GitHub committed 2026-07-06 12:33:51 +02:00
1 parent 953fbd74be
commit 9749877df6
7 files changed
+201 -120

No files matched your search

+1 -1
View File
@@ -432,7 +432,7 @@ impl Player {
panic!("Error recorded in trace: {error}");
}
Action::CreateBlas { id, desc, sizes } => {
let blas = device.create_blas(&desc, sizes).expect("create_blas error");
let (blas, _error) = device.create_blas(&desc, sizes);
self.blas_s.insert(id, blas);
}
Action::DropBlas(id) => {
+1 -1
View File
@@ -322,7 +322,7 @@ impl Global {
let hub = &self.hub;
let blas = hub.blas_s.get(id).get().ok()?;
let blas = hub.blas_s.get(id);
SnatchableResourceGuard::new(blas)
}
+8 -10
View File
@@ -50,10 +50,6 @@ struct TlasStore<'a> {
}
impl Global {
fn resolve_blas_id(&self, blas_id: BlasId) -> Result<Arc<Blas>, InvalidResourceError> {
self.hub.blas_s.get(blas_id).get()
}
fn resolve_tlas_id(&self, tlas_id: TlasId) -> Result<Arc<Tlas>, InvalidResourceError> {
self.hub.tlas_s.get(tlas_id).get()
}
@@ -81,7 +77,8 @@ impl Global {
let mut build_command = AsBuild::with_capacity(blas_ids.len(), tlas_ids.len());
for blas in blas_ids {
let blas = hub.blas_s.get(*blas).get()?;
let blas = hub.blas_s.get(*blas);
blas.check_is_valid()?;
build_command.blas_s_built.push(blas);
}
@@ -153,10 +150,9 @@ impl Global {
ArcBlasGeometries::AabbGeometries(aabb_geo)
}
};
Ok(ArcBlasBuildEntry {
blas: self.resolve_blas_id(blas_entry.blas_id)?,
geometries,
})
let blas = hub.blas_s.get(blas_entry.blas_id);
blas.check_is_valid()?;
Ok(ArcBlasBuildEntry { blas, geometries })
})
.collect::<Result<_, BuildAccelerationStructureError>>()?;
@@ -168,8 +164,10 @@ impl Global {
instance
.as_ref()
.map(|instance| {
let blas = hub.blas_s.get(instance.blas_id);
blas.check_is_valid()?;
Ok(ArcTlasInstance {
blas: self.resolve_blas_id(instance.blas_id)?,
blas,
transform: *instance.transform,
custom_data: instance.custom_data,
mask: instance.mask,
+61 -42
View File
@@ -1,4 +1,6 @@
use alloc::{boxed::Box, string::ToString, sync::Arc, vec, vec::Vec};
#[cfg(feature = "trace")]
use alloc::string::ToString as _;
use alloc::{boxed::Box, sync::Arc, vec, vec::Vec};
use core::{
iter,
mem::{self, ManuallyDrop},
@@ -33,11 +35,11 @@ use crate::{
lock::{rank, Mutex, MutexGuard, RwLock, RwLockWriteGuard},
ray_tracing::{BlasCompactReadyPendingClosure, CompactBlasError},
resource::{
Blas, BlasCompactState, Buffer, BufferAccessError, BufferMapState, DestroyedBuffer,
DestroyedQuerySet, DestroyedResourceError, DestroyedTexture, Fallible,
FlushedStagingBuffer, InvalidOrDestroyedResourceError, InvalidResourceError, Labeled,
ParentDevice, ResourceErrorIdent, StagingBuffer, Texture, TextureInner, Trackable,
TrackingData,
Blas, BlasCompactState, BlasDescriptor, BlasState, Buffer, BufferAccessError,
BufferMapState, DestroyedBuffer, DestroyedQuerySet, DestroyedResourceError,
DestroyedTexture, Fallible, FlushedStagingBuffer, InvalidOrDestroyedResourceError,
InvalidResourceError, Labeled, ParentDevice, ResourceErrorIdent, ResourceState,
StagingBuffer, Texture, TextureInner, Trackable, TrackingData,
},
resource_log,
scratch::ScratchBuffer,
@@ -1761,13 +1763,52 @@ impl Queue {
self.lock_life().add_work_done_closure(closure)
}
pub fn compact_blas(&self, blas: &Arc<Blas>) -> Result<Arc<Blas>, CompactBlasError> {
#[allow(trivial_casts)]
pub fn compact_blas(&self, blas: &Arc<Blas>) -> (Arc<Blas>, Option<CompactBlasError>) {
api_log!(
"Queue::compact_blas {:?}, {:?}",
self as *const _,
Arc::as_ptr(blas)
);
let (blas, error) = match self.compact_blas_inner(blas) {
Ok(blas) => (blas, None),
Err(err) => {
let new_label = blas.label.clone() + " (compacted)";
(
Blas::invalid(
self.device.clone(),
&BlasDescriptor {
label: Some(new_label.into()),
flags: blas.flags,
update_mode: blas.update_mode,
},
),
Some(err),
)
}
};
// TODO: Tracing
(blas, error)
}
pub(crate) fn compact_blas_inner(
&self,
blas: &Arc<Blas>,
) -> Result<Arc<Blas>, CompactBlasError> {
profiling::scope!("Queue::compact_blas");
api_log!("Queue::compact_blas");
let new_label = blas.label.clone() + " (compacted)";
self.device.check_is_valid()?;
self.device
.require_features(wgpu_types::Features::EXPERIMENTAL_RAY_QUERY)?;
blas.check_is_valid()?;
self.same_device_as(blas.as_ref())?;
let device = blas.device.clone();
@@ -1821,7 +1862,9 @@ impl Queue {
.unwrap();
let new_blas = Arc::new(Blas {
raw: Snatchable::new(raw),
state: ResourceState::Valid(BlasState {
raw: Snatchable::new(raw),
}),
device: device.clone(),
size_info,
sizes: blas.sizes.clone(),
@@ -1839,6 +1882,12 @@ impl Queue {
pending_writes.insert_blas(blas);
pending_writes.insert_blas(&new_blas);
// We should have no more errors after this because we have marked the command encoder as successful.
let old_blas_size = blas.size_info.acceleration_structure_size;
let new_blas_size = new_blas.size_info.acceleration_structure_size;
api_log!("CommandEncoder::compact_blas {:?} (size: {old_blas_size}) -> {:?} (size: {new_blas_size})", Arc::as_ptr(blas), Arc::as_ptr(&new_blas));
Ok(new_blas)
}
}
@@ -2006,47 +2055,17 @@ impl Global {
blas_id: BlasId,
id_in: Option<BlasId>,
) -> (BlasId, Option<u64>, Option<CompactBlasError>) {
api_log!("Queue::compact_blas {queue_id:?}, {blas_id:?}");
let fid = self.hub.blas_s.prepare(id_in);
let queue = self.hub.queues.get(queue_id);
let blas = self.hub.blas_s.get(blas_id);
let device = &queue.device;
// TODO: Tracing
let (blas, error) = queue.compact_blas(&blas);
let error = 'error: {
match device.require_features(wgpu_types::Features::EXPERIMENTAL_RAY_QUERY) {
Ok(_) => {}
Err(err) => break 'error err.into(),
}
let handle = blas.handle();
let id = fid.assign(blas);
let blas = match blas.get() {
Ok(blas) => blas,
Err(err) => break 'error err.into(),
};
let new_blas = match queue.compact_blas(&blas) {
Ok(blas) => blas,
Err(err) => break 'error err,
};
// We should have no more errors after this because we have marked the command encoder as successful.
let old_blas_size = blas.size_info.acceleration_structure_size;
let new_blas_size = new_blas.size_info.acceleration_structure_size;
let handle = new_blas.handle;
let id = fid.assign(Fallible::Valid(new_blas));
api_log!("CommandEncoder::compact_blas {blas_id:?} (size: {old_blas_size}) -> {id:?} (size: {new_blas_size})");
return (id, Some(handle), None);
};
let id = fid.assign(Fallible::Invalid(Arc::new(error.to_string())));
(id, None, Some(error))
(id, handle, error)
}
}
+37 -59
View File
@@ -29,6 +29,31 @@ impl Device {
self: &Arc<Self>,
blas_desc: &resource::BlasDescriptor,
sizes: wgt::BlasGeometrySizeDescriptors,
) -> (Arc<resource::Blas>, Option<CreateBlasError>) {
#[cfg(feature = "trace")]
let trace_sizes = sizes.clone();
let (blas, error) = match self.create_blas_inner(blas_desc, sizes) {
Ok(blas) => (blas, None),
Err(err) => (resource::Blas::invalid(self.clone(), blas_desc), Some(err)),
};
#[cfg(feature = "trace")]
if let Some(trace) = self.trace.lock().as_mut() {
trace.add(Action::CreateBlas {
id: blas.to_trace(),
desc: blas_desc.clone(),
sizes: trace_sizes,
});
}
api_log!("Device::create_blas -> {:?}", Arc::as_ptr(&blas));
(blas, error)
}
pub(crate) fn create_blas_inner(
self: &Arc<Self>,
blas_desc: &resource::BlasDescriptor,
sizes: wgt::BlasGeometrySizeDescriptors,
) -> Result<Arc<resource::Blas>, CreateBlasError> {
self.check_is_valid()?;
self.require_features(Features::EXPERIMENTAL_RAY_QUERY)?;
@@ -194,7 +219,9 @@ impl Device {
};
Ok(Arc::new(resource::Blas {
raw: Snatchable::new(raw),
state: resource::ResourceState::Valid(resource::BlasState {
raw: Snatchable::new(raw),
}),
device: self.clone(),
size_info,
sizes,
@@ -309,35 +336,15 @@ impl Global {
let fid = self.hub.blas_s.prepare(id_in);
let error = 'error: {
let device = self.hub.devices.get(device_id);
let device = self.hub.devices.get(device_id);
#[cfg(feature = "trace")]
let trace_sizes = sizes.clone();
let (blas, error) = device.create_blas(desc, sizes);
let blas = match device.create_blas(desc, sizes) {
Ok(blas) => blas,
Err(e) => break 'error e,
};
let handle = blas.handle;
let handle = blas.handle();
#[cfg(feature = "trace")]
if let Some(trace) = device.trace.lock().as_mut() {
trace.add(Action::CreateBlas {
id: blas.to_trace(),
desc: desc.clone(),
sizes: trace_sizes,
});
}
let id = fid.assign(blas);
let id = fid.assign(Fallible::Valid(blas));
api_log!("Device::create_blas -> {id:?}");
return (id, Some(handle), None);
};
let id = fid.assign(Fallible::Invalid(Arc::new(error.to_string())));
(id, None, Some(error))
(id, handle, error)
}
pub fn device_create_tlas(
@@ -377,17 +384,7 @@ impl Global {
}
pub fn blas_drop(&self, blas_id: BlasId) {
profiling::scope!("Blas::drop");
api_log!("Blas::drop {blas_id:?}");
let _blas = self.hub.blas_s.remove(blas_id);
#[cfg(feature = "trace")]
if let Ok(blas) = _blas.get() {
if let Some(t) = blas.device.trace.lock().as_mut() {
t.add(Action::DropBlas(blas.to_trace()));
}
}
}
pub fn tlas_drop(&self, tlas_id: TlasId) {
@@ -409,37 +406,18 @@ impl Global {
blas_id: BlasId,
callback: Option<BlasCompactCallback>,
) -> Result<crate::SubmissionIndex, BlasPrepareCompactError> {
profiling::scope!("Blas::prepare_compact_async");
api_log!("Blas::prepare_compact_async {blas_id:?}");
let hub = &self.hub;
let compact_result = match hub.blas_s.get(blas_id).get() {
Ok(blas) => blas.prepare_compact_async(callback),
Err(e) => Err((callback, e.into())),
};
let blas = hub.blas_s.get(blas_id);
match compact_result {
Ok(submission_index) => Ok(submission_index),
Err((mut callback, err)) => {
if let Some(callback) = callback.take() {
callback(Err(err.clone()));
}
Err(err)
}
}
blas.prepare_compact_async(callback)
}
pub fn ready_for_compaction(&self, blas_id: BlasId) -> Result<bool, InvalidResourceError> {
profiling::scope!("Blas::prepare_compact_async");
api_log!("Blas::prepare_compact_async {blas_id:?}");
let hub = &self.hub;
let blas = hub.blas_s.get(blas_id).get()?;
let blas = hub.blas_s.get(blas_id);
let lock = blas.compacted_state.lock();
Ok(matches!(*lock, BlasCompactState::Ready { .. }))
blas.ready_for_compaction()
}
}
+1 -1
View File
@@ -211,7 +211,7 @@ pub struct Hub {
pub(crate) texture_views: Registry<Arc<TextureView>>,
pub(crate) external_textures: Registry<Fallible<ExternalTexture>>,
pub(crate) samplers: Registry<Arc<Sampler>>,
pub(crate) blas_s: Registry<Fallible<Blas>>,
pub(crate) blas_s: Registry<Arc<Blas>>,
pub(crate) tlas_s: Registry<Fallible<Tlas>>,
pub(crate) render_passes: Registry<Arc<Mutex<RenderPass>>>,
pub(crate) compute_passes: Registry<Arc<Mutex<ComputePass>>>,
+92 -6
View File
@@ -2647,8 +2647,13 @@ unsafe impl Send for BlasCompactState {}
unsafe impl Sync for BlasCompactState {}
#[derive(Debug)]
pub struct Blas {
pub(crate) struct BlasState {
pub(crate) raw: Snatchable<Box<dyn hal::DynAccelerationStructure>>,
}
#[derive(Debug)]
pub struct Blas {
pub(crate) state: ResourceState<BlasState>,
pub(crate) device: Arc<Device>,
pub(crate) size_info: hal::AccelerationStructureBuildSizes,
pub(crate) sizes: wgt::BlasGeometrySizeDescriptors,
@@ -2664,12 +2669,22 @@ pub struct Blas {
}
impl Drop for Blas {
#[allow(trivial_casts)]
fn drop(&mut self) {
profiling::scope!("Blas::drop");
api_log!("Blas::drop {:?}", self as *const _);
#[cfg(feature = "trace")]
if let Some(t) = self.device.trace.lock().as_mut() {
use crate::device::trace::{to_trace, Action};
t.add(Action::DropBlas(unsafe { to_trace(self) }));
}
resource_log!("Destroy raw {}", self.error_ident());
// SAFETY: We are in the Drop impl, and we don't use self.raw or self.compaction_buffer anymore after this point.
if let Some(raw) = self.raw.take() {
unsafe {
self.device.raw().destroy_acceleration_structure(raw);
if let ResourceState::Valid(state) = &mut self.state {
if let Some(raw) = state.raw.take() {
unsafe {
self.device.raw().destroy_acceleration_structure(raw);
}
}
}
if let Some(mut raw) = self.compaction_buffer.take() {
@@ -2686,12 +2701,79 @@ impl RawResourceAccess for Blas {
type DynResource = dyn hal::DynAccelerationStructure;
fn raw<'a>(&'a self, guard: &'a SnatchGuard) -> Option<&'a Self::DynResource> {
self.raw.get(guard).map(|it| it.as_ref())
self.state().ok()?.raw.get(guard).map(|it| it.as_ref())
}
}
impl Blas {
pub(crate) fn prepare_compact_async(
pub(crate) fn state(&self) -> Result<&BlasState, InvalidResourceError> {
match &self.state {
ResourceState::Valid(state) => Ok(state),
ResourceState::Invalid => Err(InvalidResourceError(self.error_ident())),
}
}
pub(crate) fn check_is_valid(&self) -> Result<(), InvalidResourceError> {
self.state().map(|_| ())
}
pub(crate) fn invalid(device: Arc<Device>, desc: &BlasDescriptor) -> Arc<Self> {
Arc::new(Blas {
state: ResourceState::Invalid,
size_info: hal::AccelerationStructureBuildSizes {
acceleration_structure_size: 0,
update_scratch_size: 0,
build_scratch_size: 0,
},
sizes: wgt::BlasGeometrySizeDescriptors::Triangles {
descriptors: Vec::new(),
},
flags: desc.flags,
update_mode: desc.update_mode,
built_index: RwLock::new(rank::BLAS_BUILT_INDEX, None),
handle: 0,
label: desc.label.to_string(),
tracking_data: TrackingData::new(device.tracker_indices.blas_s.clone()),
device,
compaction_buffer: None,
compacted_state: Mutex::new(rank::BLAS_COMPACTION_STATE, BlasCompactState::Idle),
})
}
pub fn handle(&self) -> Option<u64> {
Some(self.handle)
}
pub fn ready_for_compaction(self: &Arc<Self>) -> Result<bool, InvalidResourceError> {
profiling::scope!("Blas::prepare_compact_async");
api_log!("Blas::prepare_compact_async {:?}", Arc::as_ptr(self));
self.check_is_valid()?;
let state = self.compacted_state.lock();
Ok(matches!(*state, BlasCompactState::Ready { .. }))
}
pub fn prepare_compact_async(
self: &Arc<Self>,
callback: Option<BlasCompactCallback>,
) -> Result<SubmissionIndex, BlasPrepareCompactError> {
profiling::scope!("Blas::prepare_compact_async");
api_log!("Blas::prepare_compact_async {:?}", Arc::as_ptr(self));
let compact_result = self.prepare_compact_async_inner(callback);
match compact_result {
Ok(submission_index) => Ok(submission_index),
Err((mut callback, err)) => {
if let Some(callback) = callback.take() {
callback(Err(err.clone()));
}
Err(err)
}
}
}
fn prepare_compact_async_inner(
self: &Arc<Self>,
op: Option<BlasCompactCallback>,
) -> Result<SubmissionIndex, (Option<BlasCompactCallback>, BlasPrepareCompactError)> {
@@ -2700,6 +2782,10 @@ impl Blas {
return Err((op, e.into()));
}
if let Err(e) = self.check_is_valid() {
return Err((op, e.into()));
}
if self.built_index.read().is_none() {
return Err((op, BlasPrepareCompactError::NotBuilt));
}