Struct LocalTuner 

pub struct LocalTuner<AK: AutotuneKey, ID> { /* private fields */ }

A local tuner allows to create a tuner for a specific key that can be different from the server key.

Implementations

impl<AK, ID> LocalTuner<AK, ID>

where AK: AutotuneKey + 'static, ID: Hash + PartialEq + Eq + Clone + Display,

pub const fn new(name: &'static str) -> Self

Create a new local tuner.

pub fn init<I, Out, Id, F>( &self, id: &ID, init_set: F, ) -> Arc<TunableSet<AK, I, Out, Id>>

where F: Fn() -> TunableSet<AK, I, Out, Id> + 'static + Send + Sync, Id: Send + Sync + 'static, I: TuneInputs, Out: AutotuneOutput,

Get or initialize the TunableSet for id.

Returns a cached Arc<TunableSet> keyed by the TypeId of init_set and by id, so the initializer runs once per device rather than once per process.

The device is part of the key because a set is routinely built from the device it will run on: a closure captures that device’s Client to ask what it supports, or reads its hardware properties to decide which tunables are worth offering at all. Keyed by the initializer alone, whichever device tuned first would answer those questions for every device that followed — promoting kernels onto hardware that cannot run them, or withholding kernels from hardware that can.

pub fn fastest_identity<I, Out, Id>( &self, id: &ID, operations: &TunableSet<AK, I, Out, Id>, key: &AK, ) -> Option<Id>

where I: TuneInputs, Id: Clone,

What the fastest tunable in operations for key on id is identified by: None until a result for the key is settled — tuned by a round in this process, or read back from disk and validated by an execute.

operations must be the set id executes, as init returns it for the initializer execute is handed: a result is an index into that set, and results are kept per id alone, so a set another initializer built under the same id would map it onto another tunable.

It reads results and never produces one: it never starts a round, never waits on one in flight, never validates a persisted result, and never resets the tuner’s cache after an environment switch — it reports nothing settled there until the next execute.

pub fn clear(&self)

Clear the autotune state.

pub fn execute<'a, I: TuneInputs, Out, Id>( &self, id: &ID, client: &Client, operations: Arc<TunableSet<AK, I, Out, Id>>, inputs: <I as TuneInputs>::At<'a>, ) -> Out

where <I as TuneInputs>::At<'a>: Clone + Send, Out: AutotuneOutput, Id: Send + Sync,

Execute the fastest operation in a TunableSet, triggering a tuning pass on the first call for a given key.