Struct Kernels 

pub struct Kernels(/* private fields */);

Loaded kernels, keyed by the artifact their specialization compiles to.

The compiler already caches compilation on disk. This caches the loaded executable, which is what a dispatch loop needs: turning a cached artifact into a crate::gpu::Kernel is a native load every time, and a model that dispatches the same kernel per block would pay it per block. Every consumer of this crate wrote this cache, so it lives here instead.

The key is the artifact’s own identity — the same digest the disk cache uses — rather than whatever the caller derived a request from, so two requests that compile to the same artifact share one executable.

Kernels are device-scoped, so a cache serves one device and refuses another.

Implementations

impl Kernels

pub fn keyed<K>(self) -> KeyedKernels<K>

Index this cache by a caller’s compact request key.

Source hashing and specialization construction happen only on a key miss. Distinct caller keys that name the same artifact still share one loaded executable. Include every input that changes the source or specialization in the key.

pub fn new(compiler: Compiler) -> Self

An empty cache over a compiler. Clone it to share one cache.

pub fn reporting( self, report: impl Fn(&Artifact) + Send + Sync + 'static, ) -> Self

Call report with each artifact as it is built, once, before it loads.

A cache that returned only kernels would swallow what the compiler said about them: warnings, and the backend remarks that are the only warning a kernel is spilling registers. Cache hits report nothing, having built nothing. Installing a reporter updates every clone and existing pending handle. An invocation already in progress may finish using the previous reporter. The callback must not build or resolve requests on this same cache.

pub fn compiler(&self) -> &Compiler

The compiler these were built with.

pub fn len(&self) -> usize

How many kernels are loaded.

pub fn is_empty(&self) -> bool

Whether any kernel is loaded.

pub unsafe fn get( &self, stream: &Stream, source: &str, spec: &Specialization, ) -> Result<Kernel>

Compile spec from source if needed and load it, or return the loaded kernel. Outstanding Kernels::requests are left alone.

Safety

source must be trusted Loom: its compiled output is loaded as native code, as for crate::Stream::load_artifact.

pub fn request(&self, source: &str, spec: &Specialization) -> Result<Pending>

Ask for a kernel without building it. Nothing is compiled until Kernels::build or the first Pending::resolve, and then every outstanding request is built at once across the compiler’s workspaces — so a consumer can name its whole set first and pay for it in one batch.

pub unsafe fn build(&self, stream: &Stream) -> Result<()>

Build every outstanding request, in one batch. Concurrent builds wait for the active batch before checking for more work.

Safety

As Kernels::get, for every source passed to Kernels::request.

Trait Implementations

impl Clone for Kernels

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Kernels

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

Formats the value using the given formatter.