Struct Queue 

pub struct Queue {
    raw: Box<dyn DynQueue>,
    pub(crate) pending_writes: Mutex<PendingWrites>,
    life_tracker: Mutex<LifetimeTracker>,
    pub(crate) device: Arc<Device>,
}

Fields

raw: Box<dyn DynQueue>

pending_writes: Mutex<PendingWrites>

life_tracker: Mutex<LifetimeTracker>

device: Arc<Device>

Implementations

impl Queue

pub(crate) fn new( device: Arc<Device>, raw: Box<dyn DynQueue>, instance_flags: InstanceFlags, ) -> Result<Self, DeviceError>

pub(crate) fn raw(&self) -> &dyn DynQueue

pub(crate) fn lock_life<'a>(&'a self) -> MutexGuard<'a, LifetimeTracker>

pub(crate) fn prepare_surface_texture_for_present( &self, texture: &Arc<Texture>, ) -> Result<(), DeviceError>

Ensure the surface texture is in the PRESENT state, clearing it if it was never rendered to. Submits any necessary work to the GPU before the HAL present call.

See https://github.com/gfx-rs/wgpu/issues/6748

pub(crate) fn maintain( &self, submission_index: u64, snatch_guard: &SnatchGuard<'_>, ) -> (SmallVec<[SubmittedWorkDoneClosure; 1]>, Vec<BufferMapPendingClosure>, Vec<BlasCompactReadyPendingClosure>, bool)

impl Queue

pub fn write_buffer( &self, buffer: Arc<Buffer>, buffer_offset: BufferAddress, data: &[u8], ) -> Result<(), QueueWriteError>

pub fn create_staging_buffer( &self, buffer_size: BufferSize, ) -> Result<(StagingBuffer, NonNull<u8>), QueueWriteError>

pub fn write_staging_buffer( &self, buffer: Fallible<Buffer>, buffer_offset: BufferAddress, staging_buffer: StagingBuffer, ) -> Result<(), QueueWriteError>

pub fn validate_write_buffer( &self, buffer: Fallible<Buffer>, buffer_offset: u64, buffer_size: BufferSize, ) -> Result<(), QueueWriteError>

fn validate_write_buffer_impl( &self, buffer: &Buffer, buffer_offset: u64, buffer_size: u64, ) -> Result<(), TransferError>

fn write_staging_buffer_impl( &self, snatch_guard: &SnatchGuard<'_>, pending_writes: &mut PendingWrites, staging_buffer: &FlushedStagingBuffer, buffer: Arc<Buffer>, buffer_offset: u64, ) -> Result<(), QueueWriteError>

pub fn write_texture( &self, destination: TexelCopyTextureInfo<Arc<Texture>>, data: &[u8], data_layout: &TexelCopyBufferLayout, size: &Extent3d, ) -> Result<(), QueueWriteError>

pub fn flush_writes_for_buffer( &self, buffer: &Arc<Buffer>, snatch_guard: SnatchGuard<'_>, ) -> Result<(), BufferAccessError>

Flush PendingWrites if it contains a write to buffer.

fn flush_pending_writes(&self) -> Result<Option<SubmissionIndex>, DeviceError>

fn trace_submission( &self, submit_index: SubmissionIndex, commands: Vec<Command<PointerReferences>>, )

Available on crate feature trace only.

fn trace_failed_submission( &self, submit_index: SubmissionIndex, commands: Option<Vec<Command<PointerReferences>>>, error: String, )

Available on crate feature trace only.

pub fn submit( &self, command_buffers: &[Arc<CommandBuffer>], ) -> Result<SubmissionIndex, (SubmissionIndex, QueueSubmitError)>

fn allocate_submission<'a>( &'a self, snatch_guard: SnatchGuard<'a>, ) -> Result<PendingSubmission<'a>, (SubmissionIndex, DeviceError)>

Allocate a submission index and prepare for a submission.

This is an internal API used in Queue::submit and other places within wgpu-core that need to submit work.

Returns the index and a PendingSubmission.

The caller passes in the already-acquired SnatchGuard. This function acquires the fence lock and the command index lock.

The caller should update PendingSubmission::executions with details of the submission.

To finalize and submit the submission, call PendingSubmission::submit (which is a convenience wrapper around Queue::submit_pending_submission).

After calling this function and before submitting, the caller must acquire the pending writes lock, and pass it to submit.

It is also acceptable to drop the PendingSubmission without submitting. This may be necessary when locks are required to access the state that determines whether a submission is needed.

fn submit_pending_submission<'a>( &self, pending_writes: MutexGuard<'_, PendingWrites>, prepared: PendingSubmission<'a>, ) -> Result<SubmissionResult<'a>, DeviceError>

Finalize and submit a PendingSubmission that was returned by Queue::allocate_submission.

This is an internal API used in Queue::submit and other places within wgpu-core that need to submit work. See Queue::allocate_submission for more details.

This function:

• Performs a HAL submission of the pending writes command encoder and any other command encoders that were added to the PendingSubmission.
• Advances last_successful_submission_index and registers the submission with the lifetime tracker.
• Returns a SubmissionResult, which contains the snatch guard and a downgraded FenceReadGuard.

pub fn get_timestamp_period(&self) -> f32

pub fn on_submitted_work_done( &self, closure: SubmittedWorkDoneClosure, ) -> Option<SubmissionIndex>

closure is guaranteed to be called.

pub fn compact_blas( &self, blas: &Arc<Blas>, ) -> Result<Arc<Blas>, CompactBlasError>

impl Queue

pub fn present(&self, surface: &Surface) -> Result<Status, SurfaceError>

Trait Implementations

impl Drop for Queue

fn drop(&mut self)

Executes the destructor for this type.

impl Labeled for Queue

fn label(&self) -> &str

Returns a string identifying this resource for logging and errors.

fn error_ident(&self) -> ResourceErrorIdent

impl ParentDevice for Queue

fn device(&self) -> &Arc<Device>

fn is_equal(self: &Arc<Self>, other: &Arc<Self>) -> bool

fn same_device_as<O: ParentDevice>(&self, other: &O) -> Result<(), DeviceError>

fn same_device(&self, device: &Device) -> Result<(), DeviceError>

impl ResourceType for Queue

const TYPE: &'static str = "Queue"