Struct KernelLoader 

pub struct KernelLoader<T: CompilationTarget> { /* private fields */ }

Every kernel a device has loaded, in front of the backend that compiles and loads the ones it has not.

A kernel it does not hold is read from the compilation store, or failing that compiled and stored, then loaded — in that order on every backend, and recorded the same way: what differs between backends is the CompilationTarget it is generic over.

Kernels can also be queued and compiled together: the half of the work any thread can do then runs on as many threads as there are kernels, up to the configured parallelism, each taking the next kernel as it finishes one. However long the queue, it compiles in one phase that lasts about as long as its slowest kernel.

Implementations

impl<T: CompilationTarget> KernelLoader<T>

pub fn new(target: T) -> Self

A loader holding nothing yet, bound to the active environment exactly when target persists what it compiles.

pub fn load( &mut self, kernel: &dyn CubeKernel, id: &ArtifactId<VariantOf<T>>, logger: &ServerLogger, ) -> Result<T::Loaded, LaunchError>

The kernel loaded for kernel, under id, loading it first if it is not. A kernel is about to execute, so every queued kernel is compiled first — together with this one when it needs compiling.

id is kernel’s, with what the launch adds to it: the launch already built the kernel’s id, and building it again on every launch costs. A kernel already loaded, with nothing queued, costs one lookup and a clone of what was loaded; id is only cloned to compile.

Errors

The validation, compilation or load of kernel that failed, now or when it was queued. The failure is reported once and not kept, so the next launch of the kernel tries again.

pub fn compile_queued(&mut self, logger: &ServerLogger)

Compiles every queued kernel now, rather than inside the next load, so the launch that follows pays for its own kernel only. A queued kernel that fails reports it when it is launched.

pub fn enqueue(&mut self, kernel: Box<dyn CubeKernel>, variant: VariantOf<T>)

Queues kernel under variant, to be compiled with the others when the next kernel is loaded for a launch, and only then. One already loaded or queued is left alone; one that failed is tried again, its failure dropped.

The queue does not compile on its own when it grows: one phase over everything queued lasts about as long as its slowest kernel, where two phases would each wait on theirs.

Trait Implementations

impl<T: CompilationTarget + Debug> Debug for KernelLoader<T>

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

Formats the value using the given formatter.