Struct BufferTracker

pub(crate) struct BufferTracker {
    start: Vec<BufferUses>,
    end: Vec<BufferUses>,
    metadata: ResourceMetadata<Arc<Buffer>>,
    temp: Vec<PendingTransition<BufferUses>>,
}

Stores all buffer state within a command buffer.

Fields

start: Vec<BufferUses>

end: Vec<BufferUses>

metadata: ResourceMetadata<Arc<Buffer>>

temp: Vec<PendingTransition<BufferUses>>

Implementations

impl BufferTracker

pub fn new() -> Self

fn tracker_assert_in_bounds(&self, index: usize)

pub fn set_size(&mut self, size: usize)

Sets the size of all the vectors inside the tracker.

Must be called with the highest possible Buffer ID before all unsafe functions are called.

pub fn allow_index(&mut self, index: usize)

Extend the vectors to let the given index be valid.

pub fn contains(&self, buffer: &Buffer) -> bool

Returns true if the given buffer is tracked.

pub fn used_resources(&self) -> impl Iterator<Item = &Arc<Buffer>> + '_

Returns a list of all buffers tracked.

pub fn drain_transitions<'a, 'b: 'a>( &'b mut self, snatch_guard: &'a SnatchGuard<'a>, ) -> impl Iterator<Item = BufferBarrier<'a, dyn DynBuffer>>

Drains all currently pending transitions.

pub fn set_single( &mut self, buffer: &Arc<Buffer>, state: BufferUses, ) -> Option<PendingTransition<BufferUses>>

Sets the state of a single buffer.

If a transition is needed to get the buffer into the given state, that transition is returned. No more than one transition is needed.

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_from_tracker(&mut self, tracker: &Self)

Sets the given state for all buffers in the given tracker.

If a transition is needed to get the buffers into the needed state, those transitions are stored within the tracker. A subsequent call to Self::drain_transitions is needed to get those transitions.

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_from_usage_scope(&mut self, scope: &BufferUsageScope)

Sets the given state for all buffers in the given UsageScope.

If a transition is needed to get the buffers into the needed state, those transitions are stored within the tracker. A subsequent call to Self::drain_transitions is needed to get those transitions.

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_multiple( &mut self, scope: &mut BufferUsageScope, index_source: impl IntoIterator<Item = TrackerIndex>, )

Iterates through all buffers in the given bind group and adopts the state given for those buffers in the UsageScope. It also removes all touched buffers from the usage scope.

If a transition is needed to get the buffers into the needed state, those transitions are stored within the tracker. A subsequent call to Self::drain_transitions is needed to get those transitions.

This is a really funky method used by Compute Passes to generate barriers after a call to dispatch without needing to iterate over all elements in the usage scope. We use each the a given iterator of ids as a source of which IDs to look at. All the IDs must have first been added to the usage scope.

Panics

If a resource identified by index_source is not found in the usage scope.

unsafe fn insert_or_barrier_update( &mut self, index: usize, start_state_provider: BufferStateProvider<'_>, end_state_provider: Option<BufferStateProvider<'_>>, metadata_provider: ResourceMetadataProvider<'_, Arc<Buffer>>, )

If the resource isn’t tracked

• Inserts the given resource.
• Uses the start_state_provider to populate start_states
• Uses either end_state_provider or start_state_provider to populate current_states.

If the resource is tracked

• Inserts barriers from the state in current_states to the state provided by start_state_provider.
• Updates the current_states with either the state from end_state_provider or start_state_provider.

Any barriers are added to the barrier vector.

Safety

Indexes must be valid indexes into all arrays passed in to this function, either directly or via metadata or provider structs.