Struct CpuBatchThresholds 

pub struct CpuBatchThresholds { /* private fields */ }

Thresholds that CpuBatchStrategy::Auto applies.

The defaults are the values the backend used before these knobs existed; they are not tuned results.

Examples

use tenferro_cpu::CpuBatchThresholds;

let thresholds = CpuBatchThresholds::default()
    .with_vendor_batch_max_item_dim(8)
    .with_outer_min_items(4);
assert_eq!(thresholds.vendor_batch_max_item_dim(), 8);
assert_eq!(thresholds.outer_min_items(), 4);
assert_eq!(thresholds.outer_min_items_per_lane(), 1);

Implementations

impl CpuBatchThresholds

pub fn vendor_batch_max_item_dim(&self) -> usize

Per-item work: the largest m, n and k for which Auto lets a vendor batch call (cblas_?gemm_batch) handle a grouped GEMM batch.

Strided batched contractions do not use this cutoff: under Auto they keep one provider GEMM per item, and reach the vendor batch call only through CpuBatchStrategy::WholeBatchVendor.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().vendor_batch_max_item_dim(), 16);

pub fn outer_min_items(&self) -> usize

Total batch work: the fewest items for which Auto fans out.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().outer_min_items(), 2);

pub fn outer_min_items_per_lane(&self) -> usize

Chunk granularity: the fewest items each lane must receive before Auto fans a batch out over every lane.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().outer_min_items_per_lane(), 1);

pub fn lane_item_overhead_ns(&self) -> usize

Lane cost model: the estimated fixed cost of one GEMM item, in nanoseconds, that a lane must amortize.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().lane_item_overhead_ns(), 50);

pub fn lane_muladds_per_ns(&self) -> usize

Lane cost model: estimated multiply-adds per nanosecond of one lane.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().lane_muladds_per_ns(), 16);

pub fn lane_min_work_ns(&self) -> usize

Lane cost model: the least estimated work, in nanoseconds, each lane must receive before Auto splits a batch inside an entered session. Zero lets the item thresholds alone decide.

Examples

assert_eq!(tenferro_cpu::CpuBatchThresholds::default().lane_min_work_ns(), 8_000);

pub fn with_lane_item_overhead_ns(self, nanoseconds: usize) -> Self

Return these thresholds with a different per-item lane overhead.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_lane_item_overhead_ns(100);
assert_eq!(thresholds.lane_item_overhead_ns(), 100);

pub fn with_lane_muladds_per_ns(self, muladds: usize) -> Self

Return these thresholds with a different lane throughput estimate. Zero is treated as one multiply-add per nanosecond.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_lane_muladds_per_ns(32);
assert_eq!(thresholds.lane_muladds_per_ns(), 32);

pub fn with_lane_min_work_ns(self, nanoseconds: usize) -> Self

Return these thresholds with a different minimum work per lane.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_lane_min_work_ns(0);
assert_eq!(thresholds.lane_min_work_ns(), 0);

pub fn with_vendor_batch_max_item_dim(self, limit: usize) -> Self

Return these thresholds with a different vendor-batch item limit.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_vendor_batch_max_item_dim(0);
assert_eq!(thresholds.vendor_batch_max_item_dim(), 0);

pub fn with_outer_min_items(self, items: usize) -> Self

Return these thresholds with a different minimum fan-out batch size.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_outer_min_items(64);
assert_eq!(thresholds.outer_min_items(), 64);

pub fn with_outer_min_items_per_lane(self, items: usize) -> Self

Return these thresholds with a different minimum chunk per lane.

Examples

use tenferro_cpu::CpuBatchThresholds;
let thresholds = CpuBatchThresholds::default().with_outer_min_items_per_lane(8);
assert_eq!(thresholds.outer_min_items_per_lane(), 8);

pub fn fans_out(&self, items: usize, lanes: usize) -> bool

Whether Auto fans items out over lanes lanes: more than one lane, at least Self::outer_min_items items, and at least Self::outer_min_items_per_lane items for every lane.

Examples

use tenferro_cpu::CpuBatchThresholds;

let thresholds = CpuBatchThresholds::default();
assert!(thresholds.fans_out(8, 4));
assert!(!thresholds.fans_out(3, 4));
assert!(!thresholds.fans_out(8, 1));

Trait Implementations

impl Clone for CpuBatchThresholds

fn clone(&self) -> CpuBatchThresholds

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for CpuBatchThresholds

impl Debug for CpuBatchThresholds

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

Formats the value using the given formatter.

impl Default for CpuBatchThresholds

fn default() -> Self

Returns the “default value” for a type.

impl Eq for CpuBatchThresholds

impl Hash for CpuBatchThresholds

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for CpuBatchThresholds

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for CpuBatchThresholds