Struct BatchQuery 

#[non_exhaustive]
pub struct BatchQuery {
    pub items: usize,
    pub item_muladds: f64,
    pub item_parallel: bool,
    pub vendor_batch: bool,
    pub balanced_lanes: bool,
    pub outer_only_when_item_serial: bool,
}

What one batch of one route looks like to batch_decision.

Work is described by an estimate, not by dimensions: each family supplies the multiply-adds of one item (GEMM mnk, LU n^3/3, solve n^2 k, QR 2mn^2/3, with complex elements weighing four). The two booleans and balanced_lanes say what the route permits; they are how the legacy rules above become inputs instead of hidden constants.

Examples

use tcontract_exec::batch::BatchQuery;

let query = BatchQuery::new(32, 4096.0)
    .with_item_parallel(false)
    .with_vendor_batch(true);
assert_eq!(query.items, 32);
assert!(!query.item_parallel);
assert!(query.vendor_batch);

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

items: usize

Number of independent items; 0 means there is no work.

item_muladds: f64

Multiply-adds of one item.

item_parallel: bool

The route permits item-parallel width greater than one, i.e. item_threads > 1 is meaningful. Auto keeps item threads one when this is false.

vendor_batch: bool

The route has a vendor call for the whole batch at this shape. BatchStrategy::WholeBatchVendor is available only when this is true.

balanced_lanes: bool

Auto may only keep lanes when every lane is non-empty, the split is near-even and the batch alone fills the narrowed budget: the packed driver’s balanced-lanes rule.

outer_only_when_item_serial: bool

Auto prefers the inner route (one lane, the item kernel gets a team) and fans out over items only when one item alone cannot use a team: the faer batched-GEMM rule. The item width is then the width of one item, not the whole budget.

Implementations

impl BatchQuery

pub fn new(items: usize, item_muladds: f64) -> Self

A query for items items of item_muladds multiply-adds each, on a route that permits item parallelism and has no vendor batch route.

pub fn with_item_parallel(self, item_parallel: bool) -> Self

Return this query with the item-parallel capability set.

pub fn with_vendor_batch(self, vendor_batch: bool) -> Self

Return this query with the vendor batch capability set.

pub fn with_balanced_lanes(self, balanced_lanes: bool) -> Self

Return this query with the balanced-lanes capability set.

pub fn with_outer_only_when_item_serial(self, value: bool) -> Self

Return this query with the “outer only when one item cannot use a team” capability set (the faer batched-GEMM rule).

Trait Implementations

impl Clone for BatchQuery

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for BatchQuery

impl Debug for BatchQuery

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

Formats the value using the given formatter.

impl PartialEq for BatchQuery

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl StructuralPartialEq for BatchQuery