Struct SlabBuffer

pub struct SlabBuffer<T> { /* private fields */ }

A thin wrapper around a buffer T that provides the ability to tell if the buffer has been invalidated by the SlabAllocator that it originated from.

Invalidation happens when the slab resizes. For this reason it is important to create as many values as necessary before calling SlabAllocator::commit to avoid unnecessary invalidation.

Implementations

impl<T> SlabBuffer<T>

pub fn creation_time(&self) -> usize

Returns the timestamp at which the internal buffer was created.

The returned timestamp is not a unix timestamp. It is a monotonically increasing count of buffer invalidations.

pub fn is_invalid(&self) -> bool

Determines whether this buffer has been invalidated by the slab it originated from.

pub fn is_valid(&self) -> bool

Determines whether this buffer has been invalidated by the slab it originated from.

pub fn is_new_this_commit(&self) -> bool

Returns true when the slab’s internal buffer has been recreated, and this is that newly created buffer.

This will return false if SlabAllocator::commit has been called since the creation of this buffer.

Typically this function is used by structs that own the SlabAllocator. These owning structs will call SlabAllocator::commit which returns a SlabBuffer. The callsite can then call SlabBuffer::is_new_this_commit to determine if any downstream resources (like bindgroups) need to be recreated.

This pattern keeps the owning struct from having to also store the SlabBuffer.

pub fn is_new_this_upkeep(&self) -> bool

👎Deprecated since 0.1.5: please use is_new_this_commit instead

pub fn update_if_invalid(&mut self) -> bool

Syncronize the buffer with the slab’s internal buffer.

This checks to ensure that the internal buffer is the one the slab is working with, and updates it if the slab is working with a newer buffer.

Returns true if the buffer was updated. Returns false if the buffer remains the same.

Use the result of this function to invalidate any bind groups or other downstream resources.

Note

Be cautious when using this function with multiple buffers to invalidate downstream resources. Keep in mind that using the lazy boolean operators might not have the effect you are expecting!

For example:

use craballoc::prelude::*;

let buffer_a: SlabBuffer<wgpu::Buffer> = todo!();
let buffer_b: SlabBuffer<wgpu::Buffer> = todo!();
let buffer_c: SlabBuffer<wgpu::Buffer> = todo!();

let should_invalidate = buffer_a.update_if_invalid()
    || buffer_b.update_if_invalid()
    || buffer_c.update_if_invalid();

If buffer_a is invalid, neither buffer_b nor buffer_c will be synchronized, because || is lazy in its parameter evaluation.

Instead, we should write the following:

use craballoc::prelude::*;

let buffer_a: SlabBuffer<wgpu::Buffer> = todo!();
let buffer_b: SlabBuffer<wgpu::Buffer> = todo!();
let buffer_c: SlabBuffer<wgpu::Buffer> = todo!();

let buffer_a_invalid = buffer_a.update_if_invalid();
let buffer_b_invalid = buffer_b.update_if_invalid();
let buffer_c_invalid = buffer_c.update_if_invalid();

let should_invalidate = buffer_a_invalid || buffer_b_invalid || buffer_c_invalid;

pub fn synchronize(&mut self) -> bool

👎Deprecated since 0.1.5: please use update_if_invalid instead

Trait Implementations

impl<T> Clone for SlabBuffer<T>

fn clone(&self) -> SlabBuffer<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Deref for SlabBuffer<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &<SlabBuffer<T> as Deref>::Target

Dereferences the value.