Struct nobs_vulkanism_headless::cmd::BatchSubmit

pub struct BatchSubmit { /* fields omitted */ }

Collection of streams that are submitted to the same queue.

Queue submit calles should subit as many command buffers as possible batched together, because it is a very overhead heavy operation. BatchSubmit collects Streams that can be batched together and submits them in a single call.

Submitting the batch will yield a BatchWait to synchronize with the CPU. Syncing with the CPU will yield a BatchSubmit again. This is implemented in a way that the internal vectors holding the streams does not need to be freed/allocated again.

See AutoBatch, where this ping-pong behavior is implemented in a single type.

Methods

impl BatchSubmit

pub fn new(device: Device) -> Result<Self, Error>

Creates a new batch with capacity = 1

pub fn with_capacity(device: Device, capacity: usize) -> Result<Self, Error>

Creates a new batch

Initalizes vectors to hold the streams with capacity. This might be useful if we know the maximum number of stream that are submited to the batch up front, because we do not need to resize and reallocate vectors as much.

For the same reason we should e.g. not create a new batch every frame but use an AutoBatch or Frame that lives outside of the render loop. Otherwise we would free the memory for the cached streams after every loop and reallocate them in the next frame again.

pub fn wait_for(self, sig: Semaphore, stage: ShaderStageFlags) -> Self

Waits for sig in stage

Adds the semaphore to the waiting signals. Can be called multiple times, the execution will then wait on all submitted semaphores.

pub fn push(self, stream: Stream) -> Self

Adds a stream to the batch

After this, the stream can not be modified any more. Pushing a stream into the batch will automatically call vk::EndCommandBuffer on the streams command buffer.

pub fn submit(self, queue: Queue) -> (BatchWait, Semaphore)

Submit all streams to the queue.

Returns

A tuple with

• the BatchWait used for syncronisation
• the semaphore that indicates when the batch is done with its execution

pub fn submit_immediate(self, queue: Queue) -> Result<BatchSubmit, Error>

Submits all streams to the queue and syncs with the CPU

pub fn clear(self) -> Self

Returns all stream to the pool with waive and clears all wait signals

If no buffers have been pushed this as o NOP. Otherwise no work is submitted for any of the streams in the batch.