Struct Tunable 

pub struct Tunable<K, F: TuneInputs, Output> { /* 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.

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.

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.