Struct rerun::external::eframe::egui_wgpu::wgpu::PipelineCache

pub struct PipelineCache {
    pub(crate) inner: DispatchPipelineCache,
}

Handle to a pipeline cache, which is used to accelerate creating RenderPipelines and ComputePipelines in subsequent executions

This reuse is only applicable for the same or similar devices. See util::pipeline_cache_key for some details.

Background

In most GPU drivers, shader code must be converted into a machine code which can be executed on the GPU. Generating this machine code can require a lot of computation. Pipeline caches allow this computation to be reused between executions of the program. This can be very useful for reducing program startup time.

Note that most desktop GPU drivers will manage their own caches, meaning that little advantage can be gained from this on those platforms. However, on some platforms, especially Android, drivers leave this to the application to implement.

Unfortunately, drivers do not expose whether they manage their own caches. Some reasonable policies for applications to use are:

• Manage their own pipeline cache on all platforms
• Only manage pipeline caches on Android

Usage

It is valid to use this resource when creating multiple pipelines, in which case it will likely cache each of those pipelines. It is also valid to create a new cache for each pipeline.

This resource is most useful when the data produced from it (using PipelineCache::get_data) is persisted. Care should be taken that pipeline caches are only used for the same device, as pipeline caches from compatible devices are unlikely to provide any advantage. util::pipeline_cache_key can be used as a file/directory name to help ensure that.

It is recommended to store pipeline caches atomically. If persisting to disk, this can usually be achieved by creating a temporary file, then moving/renaming the temporary file over the existing cache

Storage Usage

There is not currently an API available to reduce the size of a cache. This is due to limitations in the underlying graphics APIs used. This is especially impactful if your application is being updated, so previous caches are no longer being used.

One option to work around this is to regenerate the cache. That is, creating the pipelines which your program runs using with the stored cached data, then recreating the same pipelines using a new cache, which your application then store.

Implementations

This resource currently only works on the following backends:

• Vulkan

This type is unique to the Rust API of wgpu.

Fields

inner: DispatchPipelineCache

Implementations

impl PipelineCache

pub fn get_data(&self) -> Option<Vec<u8>>

Get the data associated with this pipeline cache. The data format is an implementation detail of wgpu. The only defined operation on this data setting it as the data field on PipelineCacheDescriptor, then to Device::create_pipeline_cache.

This function is unique to the Rust API of wgpu.

Trait Implementations

impl Clone for PipelineCache

fn clone(&self) -> PipelineCache

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PipelineCache

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Hash for PipelineCache

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PipelineCache

fn cmp(&self, other: &PipelineCache) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for PipelineCache

fn eq(&self, other: &PipelineCache) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for PipelineCache

fn partial_cmp(&self, other: &PipelineCache) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Eq for PipelineCache