summaryrefslogtreecommitdiffstats
path: root/third_party/rust/wgpu-core/src/track
diff options
context:
space:
mode:
Diffstat (limited to 'third_party/rust/wgpu-core/src/track')
-rw-r--r--third_party/rust/wgpu-core/src/track/buffer.rs65
-rw-r--r--third_party/rust/wgpu-core/src/track/metadata.rs11
-rw-r--r--third_party/rust/wgpu-core/src/track/mod.rs218
-rw-r--r--third_party/rust/wgpu-core/src/track/stateless.rs43
-rw-r--r--third_party/rust/wgpu-core/src/track/texture.rs65
5 files changed, 189 insertions, 213 deletions
diff --git a/third_party/rust/wgpu-core/src/track/buffer.rs b/third_party/rust/wgpu-core/src/track/buffer.rs
index 323d2dab9d..a30ac2a225 100644
--- a/third_party/rust/wgpu-core/src/track/buffer.rs
+++ b/third_party/rust/wgpu-core/src/track/buffer.rs
@@ -7,7 +7,7 @@
use std::{borrow::Cow, marker::PhantomData, sync::Arc};
-use super::{PendingTransition, ResourceTracker};
+use super::{PendingTransition, ResourceTracker, TrackerIndex};
use crate::{
hal_api::HalApi,
id::BufferId,
@@ -64,16 +64,16 @@ impl<A: HalApi> BufferBindGroupState<A> {
#[allow(clippy::pattern_type_mismatch)]
pub(crate) fn optimize(&self) {
let mut buffers = self.buffers.lock();
- buffers.sort_unstable_by_key(|(b, _)| b.as_info().id().unzip().0);
+ buffers.sort_unstable_by_key(|(b, _)| b.as_info().tracker_index());
}
/// Returns a list of all buffers tracked. May contain duplicates.
#[allow(clippy::pattern_type_mismatch)]
- pub fn used_ids(&self) -> impl Iterator<Item = BufferId> + '_ {
+ pub fn used_tracker_indices(&self) -> impl Iterator<Item = TrackerIndex> + '_ {
let buffers = self.buffers.lock();
buffers
.iter()
- .map(|(ref b, _)| b.as_info().id())
+ .map(|(ref b, _)| b.as_info().tracker_index())
.collect::<Vec<_>>()
.into_iter()
}
@@ -149,20 +149,6 @@ impl<A: HalApi> BufferUsageScope<A> {
resources.into_iter()
}
- pub fn get(&self, id: BufferId) -> Option<&Arc<Buffer<A>>> {
- let index = id.unzip().0 as usize;
- if index > self.metadata.size() {
- return None;
- }
- self.tracker_assert_in_bounds(index);
- unsafe {
- if self.metadata.contains_unchecked(index) {
- return Some(self.metadata.get_resource_unchecked(index));
- }
- }
- None
- }
-
/// Merge the list of buffer states in the given bind group into this usage scope.
///
/// If any of the resulting states is invalid, stops the merge and returns a usage
@@ -181,7 +167,7 @@ impl<A: HalApi> BufferUsageScope<A> {
) -> Result<(), UsageConflict> {
let buffers = bind_group.buffers.lock();
for &(ref resource, state) in &*buffers {
- let index = resource.as_info().id().unzip().0 as usize;
+ let index = resource.as_info().tracker_index().as_usize();
unsafe {
insert_or_merge(
@@ -255,7 +241,7 @@ impl<A: HalApi> BufferUsageScope<A> {
.get(id)
.map_err(|_| UsageConflict::BufferInvalid { id })?;
- let index = id.unzip().0 as usize;
+ let index = buffer.info.tracker_index().as_usize();
self.allow_index(index);
@@ -292,7 +278,7 @@ pub(crate) struct BufferTracker<A: HalApi> {
temp: Vec<PendingTransition<BufferUses>>,
}
-impl<A: HalApi> ResourceTracker<Buffer<A>> for BufferTracker<A> {
+impl<A: HalApi> ResourceTracker for BufferTracker<A> {
/// Try to remove the buffer `id` from this tracker if it is otherwise unused.
///
/// A buffer is 'otherwise unused' when the only references to it are:
@@ -313,8 +299,8 @@ impl<A: HalApi> ResourceTracker<Buffer<A>> for BufferTracker<A> {
/// [`Device::trackers`]: crate::device::Device
/// [`self.metadata`]: BufferTracker::metadata
/// [`Hub::buffers`]: crate::hub::Hub::buffers
- fn remove_abandoned(&mut self, id: BufferId) -> bool {
- let index = id.unzip().0 as usize;
+ fn remove_abandoned(&mut self, index: TrackerIndex) -> bool {
+ let index = index.as_usize();
if index > self.metadata.size() {
return false;
@@ -329,16 +315,10 @@ impl<A: HalApi> ResourceTracker<Buffer<A>> for BufferTracker<A> {
//so it's already been released from user and so it's not inside Registry\Storage
if existing_ref_count <= 2 {
self.metadata.remove(index);
- log::trace!("Buffer {:?} is not tracked anymore", id,);
return true;
- } else {
- log::trace!(
- "Buffer {:?} is still referenced from {}",
- id,
- existing_ref_count
- );
- return false;
}
+
+ return false;
}
}
true
@@ -404,8 +384,8 @@ impl<A: HalApi> BufferTracker<A> {
///
/// If the ID is higher than the length of internal vectors,
/// the vectors will be extended. A call to set_size is not needed.
- pub fn insert_single(&mut self, id: BufferId, resource: Arc<Buffer<A>>, state: BufferUses) {
- let index = id.unzip().0 as usize;
+ pub fn insert_single(&mut self, resource: Arc<Buffer<A>>, state: BufferUses) {
+ let index = resource.info.tracker_index().as_usize();
self.allow_index(index);
@@ -440,7 +420,7 @@ impl<A: HalApi> BufferTracker<A> {
/// If the ID is higher than the length of internal vectors,
/// the vectors will be extended. A call to set_size is not needed.
pub fn set_single(&mut self, buffer: &Arc<Buffer<A>>, state: BufferUses) -> SetSingleResult<A> {
- let index: usize = buffer.as_info().id().unzip().0 as usize;
+ let index: usize = buffer.as_info().tracker_index().as_usize();
self.allow_index(index);
@@ -561,16 +541,15 @@ impl<A: HalApi> BufferTracker<A> {
pub unsafe fn set_and_remove_from_usage_scope_sparse(
&mut self,
scope: &mut BufferUsageScope<A>,
- id_source: impl IntoIterator<Item = BufferId>,
+ index_source: impl IntoIterator<Item = TrackerIndex>,
) {
let incoming_size = scope.state.len();
if incoming_size > self.start.len() {
self.set_size(incoming_size);
}
- for id in id_source {
- let (index32, _, _) = id.unzip();
- let index = index32 as usize;
+ for index in index_source {
+ let index = index.as_usize();
scope.tracker_assert_in_bounds(index);
@@ -599,8 +578,8 @@ impl<A: HalApi> BufferTracker<A> {
}
#[allow(dead_code)]
- pub fn get(&self, id: BufferId) -> Option<&Arc<Buffer<A>>> {
- let index = id.unzip().0 as usize;
+ pub fn get(&self, index: TrackerIndex) -> Option<&Arc<Buffer<A>>> {
+ let index = index.as_usize();
if index > self.metadata.size() {
return None;
}
@@ -785,11 +764,7 @@ unsafe fn merge<A: HalApi>(
if invalid_resource_state(merged_state) {
return Err(UsageConflict::from_buffer(
- BufferId::zip(
- index32,
- unsafe { metadata_provider.get_epoch(index) },
- A::VARIANT,
- ),
+ unsafe { metadata_provider.get_own(index).info.id() },
*current_state,
new_state,
));
diff --git a/third_party/rust/wgpu-core/src/track/metadata.rs b/third_party/rust/wgpu-core/src/track/metadata.rs
index e5f4d5e969..744783a7fa 100644
--- a/third_party/rust/wgpu-core/src/track/metadata.rs
+++ b/third_party/rust/wgpu-core/src/track/metadata.rs
@@ -1,6 +1,6 @@
//! The `ResourceMetadata` type.
-use crate::{resource::Resource, Epoch};
+use crate::resource::Resource;
use bit_vec::BitVec;
use std::{borrow::Cow, mem, sync::Arc};
use wgt::strict_assert;
@@ -194,15 +194,6 @@ impl<T: Resource> ResourceMetadataProvider<'_, T> {
}
}
}
- /// Get the epoch from this.
- ///
- /// # Safety
- ///
- /// - The index must be in bounds of the metadata tracker if this uses an indirect source.
- #[inline(always)]
- pub(super) unsafe fn get_epoch(self, index: usize) -> Epoch {
- unsafe { self.get_own(index).as_info().id().unzip().1 }
- }
}
/// Resizes the given bitvec to the given size. I'm not sure why this is hard to do but it is.
diff --git a/third_party/rust/wgpu-core/src/track/mod.rs b/third_party/rust/wgpu-core/src/track/mod.rs
index a36280d03b..9ca37ebadc 100644
--- a/third_party/rust/wgpu-core/src/track/mod.rs
+++ b/third_party/rust/wgpu-core/src/track/mod.rs
@@ -102,16 +102,11 @@ mod stateless;
mod texture;
use crate::{
- binding_model, command, conv,
- hal_api::HalApi,
- id::{self, Id},
- pipeline, resource,
- snatch::SnatchGuard,
- storage::Storage,
+ binding_model, command, conv, hal_api::HalApi, id, pipeline, resource, snatch::SnatchGuard,
};
-use parking_lot::RwLock;
-use std::{fmt, ops};
+use parking_lot::{Mutex, RwLock};
+use std::{fmt, ops, sync::Arc};
use thiserror::Error;
pub(crate) use buffer::{BufferBindGroupState, BufferTracker, BufferUsageScope};
@@ -122,6 +117,130 @@ pub(crate) use texture::{
};
use wgt::strict_assert_ne;
+#[repr(transparent)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
+pub(crate) struct TrackerIndex(u32);
+
+impl TrackerIndex {
+ /// A dummy value to place in ResourceInfo for resources that are never tracked.
+ pub const INVALID: Self = TrackerIndex(u32::MAX);
+
+ pub fn as_usize(self) -> usize {
+ debug_assert!(self != Self::INVALID);
+ self.0 as usize
+ }
+}
+
+/// wgpu-core internally use some array-like storage for tracking resources.
+/// To that end, there needs to be a uniquely assigned index for each live resource
+/// of a certain type. This index is separate from the resource ID for various reasons:
+/// - There can be multiple resource IDs pointing the the same resource.
+/// - IDs of dead handles can be recycled while resources are internally held alive (and tracked).
+/// - The plan is to remove IDs in the long run (https://github.com/gfx-rs/wgpu/issues/5121).
+/// In order to produce these tracker indices, there is a shared TrackerIndexAllocator
+/// per resource type. Indices have the same lifetime as the internal resource they
+/// are associated to (alloc happens when creating the resource and free is called when
+/// the resource is dropped).
+struct TrackerIndexAllocator {
+ unused: Vec<TrackerIndex>,
+ next_index: TrackerIndex,
+}
+
+impl TrackerIndexAllocator {
+ pub fn new() -> Self {
+ TrackerIndexAllocator {
+ unused: Vec::new(),
+ next_index: TrackerIndex(0),
+ }
+ }
+
+ pub fn alloc(&mut self) -> TrackerIndex {
+ if let Some(index) = self.unused.pop() {
+ return index;
+ }
+
+ let index = self.next_index;
+ self.next_index.0 += 1;
+
+ index
+ }
+
+ pub fn free(&mut self, index: TrackerIndex) {
+ self.unused.push(index);
+ }
+
+ // This is used to pre-allocate the tracker storage.
+ pub fn size(&self) -> usize {
+ self.next_index.0 as usize
+ }
+}
+
+impl std::fmt::Debug for TrackerIndexAllocator {
+ fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> Result<(), std::fmt::Error> {
+ Ok(())
+ }
+}
+
+/// See TrackerIndexAllocator.
+#[derive(Debug)]
+pub(crate) struct SharedTrackerIndexAllocator {
+ inner: Mutex<TrackerIndexAllocator>,
+}
+
+impl SharedTrackerIndexAllocator {
+ pub fn new() -> Self {
+ SharedTrackerIndexAllocator {
+ inner: Mutex::new(TrackerIndexAllocator::new()),
+ }
+ }
+
+ pub fn alloc(&self) -> TrackerIndex {
+ self.inner.lock().alloc()
+ }
+
+ pub fn free(&self, index: TrackerIndex) {
+ self.inner.lock().free(index);
+ }
+
+ pub fn size(&self) -> usize {
+ self.inner.lock().size()
+ }
+}
+
+pub(crate) struct TrackerIndexAllocators {
+ pub buffers: Arc<SharedTrackerIndexAllocator>,
+ pub staging_buffers: Arc<SharedTrackerIndexAllocator>,
+ pub textures: Arc<SharedTrackerIndexAllocator>,
+ pub texture_views: Arc<SharedTrackerIndexAllocator>,
+ pub samplers: Arc<SharedTrackerIndexAllocator>,
+ pub bind_groups: Arc<SharedTrackerIndexAllocator>,
+ pub bind_group_layouts: Arc<SharedTrackerIndexAllocator>,
+ pub compute_pipelines: Arc<SharedTrackerIndexAllocator>,
+ pub render_pipelines: Arc<SharedTrackerIndexAllocator>,
+ pub pipeline_layouts: Arc<SharedTrackerIndexAllocator>,
+ pub bundles: Arc<SharedTrackerIndexAllocator>,
+ pub query_sets: Arc<SharedTrackerIndexAllocator>,
+}
+
+impl TrackerIndexAllocators {
+ pub fn new() -> Self {
+ TrackerIndexAllocators {
+ buffers: Arc::new(SharedTrackerIndexAllocator::new()),
+ staging_buffers: Arc::new(SharedTrackerIndexAllocator::new()),
+ textures: Arc::new(SharedTrackerIndexAllocator::new()),
+ texture_views: Arc::new(SharedTrackerIndexAllocator::new()),
+ samplers: Arc::new(SharedTrackerIndexAllocator::new()),
+ bind_groups: Arc::new(SharedTrackerIndexAllocator::new()),
+ bind_group_layouts: Arc::new(SharedTrackerIndexAllocator::new()),
+ compute_pipelines: Arc::new(SharedTrackerIndexAllocator::new()),
+ render_pipelines: Arc::new(SharedTrackerIndexAllocator::new()),
+ pipeline_layouts: Arc::new(SharedTrackerIndexAllocator::new()),
+ bundles: Arc::new(SharedTrackerIndexAllocator::new()),
+ query_sets: Arc::new(SharedTrackerIndexAllocator::new()),
+ }
+ }
+}
+
/// A structure containing all the information about a particular resource
/// transition. User code should be able to generate a pipeline barrier
/// based on the contents.
@@ -359,31 +478,14 @@ pub(crate) struct RenderBundleScope<A: HalApi> {
impl<A: HalApi> RenderBundleScope<A> {
/// Create the render bundle scope and pull the maximum IDs from the hubs.
- pub fn new(
- buffers: &Storage<resource::Buffer<A>>,
- textures: &Storage<resource::Texture<A>>,
- bind_groups: &Storage<binding_model::BindGroup<A>>,
- render_pipelines: &Storage<pipeline::RenderPipeline<A>>,
- query_sets: &Storage<resource::QuerySet<A>>,
- ) -> Self {
- let value = Self {
+ pub fn new() -> Self {
+ Self {
buffers: RwLock::new(BufferUsageScope::new()),
textures: RwLock::new(TextureUsageScope::new()),
bind_groups: RwLock::new(StatelessTracker::new()),
render_pipelines: RwLock::new(StatelessTracker::new()),
query_sets: RwLock::new(StatelessTracker::new()),
- };
-
- value.buffers.write().set_size(buffers.len());
- value.textures.write().set_size(textures.len());
- value.bind_groups.write().set_size(bind_groups.len());
- value
- .render_pipelines
- .write()
- .set_size(render_pipelines.len());
- value.query_sets.write().set_size(query_sets.len());
-
- value
+ }
}
/// Merge the inner contents of a bind group into the render bundle tracker.
@@ -420,17 +522,14 @@ pub(crate) struct UsageScope<A: HalApi> {
impl<A: HalApi> UsageScope<A> {
/// Create the render bundle scope and pull the maximum IDs from the hubs.
- pub fn new(
- buffers: &Storage<resource::Buffer<A>>,
- textures: &Storage<resource::Texture<A>>,
- ) -> Self {
+ pub fn new(tracker_indices: &TrackerIndexAllocators) -> Self {
let mut value = Self {
buffers: BufferUsageScope::new(),
textures: TextureUsageScope::new(),
};
- value.buffers.set_size(buffers.len());
- value.textures.set_size(textures.len());
+ value.buffers.set_size(tracker_indices.buffers.size());
+ value.textures.set_size(tracker_indices.textures.size());
value
}
@@ -478,11 +577,8 @@ impl<A: HalApi> UsageScope<A> {
}
}
-pub(crate) trait ResourceTracker<R>
-where
- R: resource::Resource,
-{
- fn remove_abandoned(&mut self, id: Id<R::Marker>) -> bool;
+pub(crate) trait ResourceTracker {
+ fn remove_abandoned(&mut self, index: TrackerIndex) -> bool;
}
/// A full double sided tracker used by CommandBuffers and the Device.
@@ -513,48 +609,6 @@ impl<A: HalApi> Tracker<A> {
}
}
- /// Pull the maximum IDs from the hubs.
- pub fn set_size(
- &mut self,
- buffers: Option<&Storage<resource::Buffer<A>>>,
- textures: Option<&Storage<resource::Texture<A>>>,
- views: Option<&Storage<resource::TextureView<A>>>,
- samplers: Option<&Storage<resource::Sampler<A>>>,
- bind_groups: Option<&Storage<binding_model::BindGroup<A>>>,
- compute_pipelines: Option<&Storage<pipeline::ComputePipeline<A>>>,
- render_pipelines: Option<&Storage<pipeline::RenderPipeline<A>>>,
- bundles: Option<&Storage<command::RenderBundle<A>>>,
- query_sets: Option<&Storage<resource::QuerySet<A>>>,
- ) {
- if let Some(buffers) = buffers {
- self.buffers.set_size(buffers.len());
- };
- if let Some(textures) = textures {
- self.textures.set_size(textures.len());
- };
- if let Some(views) = views {
- self.views.set_size(views.len());
- };
- if let Some(samplers) = samplers {
- self.samplers.set_size(samplers.len());
- };
- if let Some(bind_groups) = bind_groups {
- self.bind_groups.set_size(bind_groups.len());
- };
- if let Some(compute_pipelines) = compute_pipelines {
- self.compute_pipelines.set_size(compute_pipelines.len());
- }
- if let Some(render_pipelines) = render_pipelines {
- self.render_pipelines.set_size(render_pipelines.len());
- };
- if let Some(bundles) = bundles {
- self.bundles.set_size(bundles.len());
- };
- if let Some(query_sets) = query_sets {
- self.query_sets.set_size(query_sets.len());
- };
- }
-
/// Iterates through all resources in the given bind group and adopts
/// the state given for those resources in the UsageScope. It also
/// removes all touched resources from the usage scope.
@@ -585,7 +639,7 @@ impl<A: HalApi> Tracker<A> {
unsafe {
self.buffers.set_and_remove_from_usage_scope_sparse(
&mut scope.buffers,
- bind_group.buffers.used_ids(),
+ bind_group.buffers.used_tracker_indices(),
)
};
unsafe {
diff --git a/third_party/rust/wgpu-core/src/track/stateless.rs b/third_party/rust/wgpu-core/src/track/stateless.rs
index 4111a90f79..00225f2305 100644
--- a/third_party/rust/wgpu-core/src/track/stateless.rs
+++ b/third_party/rust/wgpu-core/src/track/stateless.rs
@@ -10,7 +10,7 @@ use parking_lot::Mutex;
use crate::{id::Id, resource::Resource, resource_log, storage::Storage, track::ResourceMetadata};
-use super::ResourceTracker;
+use super::{ResourceTracker, TrackerIndex};
/// Satisfy clippy.
type Pair<T> = (Id<<T as Resource>::Marker>, Arc<T>);
@@ -74,7 +74,7 @@ pub(crate) struct StatelessTracker<T: Resource> {
metadata: ResourceMetadata<T>,
}
-impl<T: Resource> ResourceTracker<T> for StatelessTracker<T> {
+impl<T: Resource> ResourceTracker for StatelessTracker<T> {
/// Try to remove the given resource from the tracker iff we have the last reference to the
/// resource and the epoch matches.
///
@@ -82,14 +82,14 @@ impl<T: Resource> ResourceTracker<T> for StatelessTracker<T> {
///
/// If the ID is higher than the length of internal vectors,
/// false will be returned.
- fn remove_abandoned(&mut self, id: Id<T::Marker>) -> bool {
- let index = id.unzip().0 as usize;
+ fn remove_abandoned(&mut self, index: TrackerIndex) -> bool {
+ let index = index.as_usize();
if index >= self.metadata.size() {
return false;
}
- resource_log!("StatelessTracker::remove_abandoned {id:?}");
+ resource_log!("StatelessTracker::remove_abandoned {index:?}");
self.tracker_assert_in_bounds(index);
@@ -100,17 +100,10 @@ impl<T: Resource> ResourceTracker<T> for StatelessTracker<T> {
//so it's already been released from user and so it's not inside Registry\Storage
if existing_ref_count <= 2 {
self.metadata.remove(index);
- log::trace!("{} {:?} is not tracked anymore", T::TYPE, id,);
return true;
- } else {
- log::trace!(
- "{} {:?} is still referenced from {}",
- T::TYPE,
- id,
- existing_ref_count
- );
- return false;
}
+
+ return false;
}
}
true
@@ -160,9 +153,8 @@ impl<T: Resource> StatelessTracker<T> {
///
/// If the ID is higher than the length of internal vectors,
/// the vectors will be extended. A call to set_size is not needed.
- pub fn insert_single(&mut self, id: Id<T::Marker>, resource: Arc<T>) {
- let (index32, _epoch, _) = id.unzip();
- let index = index32 as usize;
+ pub fn insert_single(&mut self, resource: Arc<T>) {
+ let index = resource.as_info().tracker_index().as_usize();
self.allow_index(index);
@@ -184,8 +176,7 @@ impl<T: Resource> StatelessTracker<T> {
) -> Option<&'a Arc<T>> {
let resource = storage.get(id).ok()?;
- let (index32, _epoch, _) = id.unzip();
- let index = index32 as usize;
+ let index = resource.as_info().tracker_index().as_usize();
self.allow_index(index);
@@ -221,18 +212,4 @@ impl<T: Resource> StatelessTracker<T> {
}
}
}
-
- pub fn get(&self, id: Id<T::Marker>) -> Option<&Arc<T>> {
- let index = id.unzip().0 as usize;
- if index > self.metadata.size() {
- return None;
- }
- self.tracker_assert_in_bounds(index);
- unsafe {
- if self.metadata.contains_unchecked(index) {
- return Some(self.metadata.get_resource_unchecked(index));
- }
- }
- None
- }
}
diff --git a/third_party/rust/wgpu-core/src/track/texture.rs b/third_party/rust/wgpu-core/src/track/texture.rs
index 601df11e1b..e7c4707c93 100644
--- a/third_party/rust/wgpu-core/src/track/texture.rs
+++ b/third_party/rust/wgpu-core/src/track/texture.rs
@@ -19,10 +19,11 @@
* will treat the contents as junk.
!*/
-use super::{range::RangedStates, PendingTransition, PendingTransitionList, ResourceTracker};
+use super::{
+ range::RangedStates, PendingTransition, PendingTransitionList, ResourceTracker, TrackerIndex,
+};
use crate::{
hal_api::HalApi,
- id::TextureId,
resource::{Resource, Texture, TextureInner},
snatch::SnatchGuard,
track::{
@@ -173,7 +174,7 @@ impl<A: HalApi> TextureBindGroupState<A> {
/// accesses will be in a constant ascending order.
pub(crate) fn optimize(&self) {
let mut textures = self.textures.lock();
- textures.sort_unstable_by_key(|v| v.texture.as_info().id().unzip().0);
+ textures.sort_unstable_by_key(|v| v.texture.as_info().tracker_index());
}
/// Returns a list of all textures tracked. May contain duplicates.
@@ -359,7 +360,7 @@ impl<A: HalApi> TextureUsageScope<A> {
selector: Option<TextureSelector>,
new_state: TextureUses,
) -> Result<(), UsageConflict> {
- let index = texture.as_info().id().unzip().0 as usize;
+ let index = texture.as_info().tracker_index().as_usize();
self.tracker_assert_in_bounds(index);
@@ -393,7 +394,7 @@ pub(crate) struct TextureTracker<A: HalApi> {
_phantom: PhantomData<A>,
}
-impl<A: HalApi> ResourceTracker<Texture<A>> for TextureTracker<A> {
+impl<A: HalApi> ResourceTracker for TextureTracker<A> {
/// Try to remove the given resource from the tracker iff we have the last reference to the
/// resource and the epoch matches.
///
@@ -401,10 +402,10 @@ impl<A: HalApi> ResourceTracker<Texture<A>> for TextureTracker<A> {
///
/// If the ID is higher than the length of internal vectors,
/// false will be returned.
- fn remove_abandoned(&mut self, id: TextureId) -> bool {
- let index = id.unzip().0 as usize;
+ fn remove_abandoned(&mut self, index: TrackerIndex) -> bool {
+ let index = index.as_usize();
- if index > self.metadata.size() {
+ if index >= self.metadata.size() {
return false;
}
@@ -419,16 +420,10 @@ impl<A: HalApi> ResourceTracker<Texture<A>> for TextureTracker<A> {
self.start_set.complex.remove(&index);
self.end_set.complex.remove(&index);
self.metadata.remove(index);
- log::trace!("Texture {:?} is not tracked anymore", id,);
return true;
- } else {
- log::trace!(
- "Texture {:?} is still referenced from {}",
- id,
- existing_ref_count
- );
- return false;
}
+
+ return false;
}
}
true
@@ -518,8 +513,8 @@ impl<A: HalApi> TextureTracker<A> {
///
/// If the ID is higher than the length of internal vectors,
/// the vectors will be extended. A call to set_size is not needed.
- pub fn insert_single(&mut self, id: TextureId, resource: Arc<Texture<A>>, usage: TextureUses) {
- let index = id.unzip().0 as usize;
+ pub fn insert_single(&mut self, resource: Arc<Texture<A>>, usage: TextureUses) {
+ let index = resource.info.tracker_index().as_usize();
self.allow_index(index);
@@ -560,7 +555,7 @@ impl<A: HalApi> TextureTracker<A> {
selector: TextureSelector,
new_state: TextureUses,
) -> Option<Drain<'_, PendingTransition<TextureUses>>> {
- let index = texture.as_info().id().unzip().0 as usize;
+ let index = texture.as_info().tracker_index().as_usize();
self.allow_index(index);
@@ -694,7 +689,7 @@ impl<A: HalApi> TextureTracker<A> {
let textures = bind_group_state.textures.lock();
for t in textures.iter() {
- let index = t.texture.as_info().id().unzip().0 as usize;
+ let index = t.texture.as_info().tracker_index().as_usize();
scope.tracker_assert_in_bounds(index);
if unsafe { !scope.metadata.contains_unchecked(index) } {
@@ -727,10 +722,10 @@ impl<A: HalApi> TextureTracker<A> {
///
/// If the ID is higher than the length of internal vectors,
/// false will be returned.
- pub fn remove(&mut self, id: TextureId) -> bool {
- let index = id.unzip().0 as usize;
+ pub fn remove(&mut self, index: TrackerIndex) -> bool {
+ let index = index.as_usize();
- if index > self.metadata.size() {
+ if index >= self.metadata.size() {
return false;
}
@@ -1080,11 +1075,7 @@ unsafe fn merge<A: HalApi>(
if invalid_resource_state(merged_state) {
return Err(UsageConflict::from_texture(
- TextureId::zip(
- index as _,
- unsafe { metadata_provider.get_epoch(index) },
- A::VARIANT,
- ),
+ unsafe { metadata_provider.get_own(index).info.id() },
texture_selector.clone(),
*current_simple,
new_simple,
@@ -1111,11 +1102,7 @@ unsafe fn merge<A: HalApi>(
if invalid_resource_state(merged_state) {
return Err(UsageConflict::from_texture(
- TextureId::zip(
- index as _,
- unsafe { metadata_provider.get_epoch(index) },
- A::VARIANT,
- ),
+ unsafe { metadata_provider.get_own(index).info.id() },
selector,
*current_simple,
new_state,
@@ -1156,11 +1143,7 @@ unsafe fn merge<A: HalApi>(
if invalid_resource_state(merged_state) {
return Err(UsageConflict::from_texture(
- TextureId::zip(
- index as _,
- unsafe { metadata_provider.get_epoch(index) },
- A::VARIANT,
- ),
+ unsafe { metadata_provider.get_own(index).info.id() },
TextureSelector {
mips: mip_id..mip_id + 1,
layers: layers.clone(),
@@ -1201,11 +1184,7 @@ unsafe fn merge<A: HalApi>(
if invalid_resource_state(merged_state) {
return Err(UsageConflict::from_texture(
- TextureId::zip(
- index as _,
- unsafe { metadata_provider.get_epoch(index) },
- A::VARIANT,
- ),
+ unsafe { metadata_provider.get_own(index).info.id() },
TextureSelector {
mips: mip_id..mip_id + 1,
layers: layers.clone(),
generated by cgit v1.2.3 (git 2.39.1) at 2024-08-15 18:08:09 +0000