Struct BatchDecision 

pub struct BatchDecision {
    pub lanes: usize,
    pub item_threads: usize,
}

The route batch_decision selected.

The route contract

A decision is the whole concurrency of one call, and a route must never discard half of it: lanes outer lanes run a contiguous share of the items, each lane may run its items on item_threads threads, and batch_decision keeps lanes * item_threads <= budget. A route that cannot run an item on a sub-team inside a lane either honours both axes or refuses a decision that asks for both — only a forced BatchStrategy::Split produces lanes > 1 together with item_threads > 1 — with crate::ExecError::StrategyUnavailable, before it writes any output. Silently running the items serially inside the lanes is not a route.

The routes in tcontract, and where each one stands:

• the faer strategy honours both axes: every item runs with Par::rayon(item_threads) inside its lane’s share of the borrowed pool, which nests there (crates/tcontract/src/strategy/faer.rs);
• the packed driver refuses it (crates/tcontract/src/driver/route.rs): its inner parallelism is a co-scheduled, barrier-bearing team, and a lane worker cannot join one without blocking on an outer barrier;
• contract_batched refuses it too (crates/tcontract/src/batch.rs): its schedule is one item per lane, or the items one after another on the whole context, as the decision log records.

Examples

use tcontract_exec::batch::BatchDecision;
let d = BatchDecision { lanes: 2, item_threads: 1 };
assert_eq!(d.lanes * d.item_threads, 2);

Fields

lanes: usize

Outer lanes; each lane runs a contiguous share of the items.

item_threads: usize

Threads one item may use. 1 for a route that runs items serially inside each lane; a BatchStrategy::Split asks for both lanes and item threads, and a route that cannot run item threads inside lanes refuses it (see the type’s route contract).

Trait Implementations

impl Clone for BatchDecision

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 BatchDecision

impl Debug for BatchDecision

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

Formats the value using the given formatter.

impl Eq for BatchDecision

impl PartialEq for BatchDecision

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for BatchDecision