Struct Tunable 

pub struct Tunable<K, F: TuneInputs, Output, Id = ()> { /* private fields */ }

A single candidate for autotune: a named TuneFn plus the groups it belongs to. A tunable is autotuned whenever any of its groups is prioritized.

Id is what the tunables of a set are identified by, () for a set whose tunables are named and nothing more.

Implementations

impl<K, F: TuneInputs, Output: 'static> Tunable<K, F, Output>

pub fn new<Func, Err>(name: &str, func: Func) -> Self

where Err: Into<String> + 'static, Func: for<'a> Fn(<F as TuneInputs>::At<'a>) -> Result<Output, Err> + Send + Sync + 'static,

Create a tunable from a closure.

The for<'a> Fn(F::At<'a>) -> _ bound is spelled out in the where-clause rather than hidden behind a helper trait, so that closure inference sees it: otherwise move |input| … picks one concrete lifetime and fails with implementation of FnOnce is not general enough wherever F::At<'a> depends on 'a.

For multi-input kernels, destructure a tuple: Tunable::new("name", |(lhs, rhs, out)| body).

A tunable in no group states no priority, so it trails the grouped candidates of its round and a short circuit among them leaves it unmeasured.

impl<K, F: TuneInputs, Output: 'static, Id> Tunable<K, F, Output, Id>

pub fn identified<Func, Err>(identity: Id, func: Func) -> Self

where Id: Display, Err: Into<String> + 'static, Func: for<'a> Fn(<F as TuneInputs>::At<'a>) -> Result<Output, Err> + Send + Sync + 'static,

A tunable identified by identity, and named by it: the value LocalTuner::fastest_identity hands back once the tunable is the fastest for a key.

For a caller that builds something else from the winner — a variant of the same kernel, say — and so needs to know which candidate won rather than only to run it again. The name a cached result is checksummed by is identity’s own, so the two cannot disagree.

pub fn group( self, group: &TuneGroup<K>, priority: impl Fn(&K) -> i8 + Send + Sync + 'static, ) -> Self

Add this tunable to a TuneGroup with the given intra-group priority.

Groups run in order of their own priority. Within a cutoff group the member priority picks one level as the round and leaves the levels under it as fallbacks. Within an ordered group it orders one round that holds every member. A negative priority skips the tunable for this key.