Struct PredicateSchedulerConfig 

pub struct PredicateSchedulerConfig {
    pub max_deterministic_lanes: usize,
    pub max_semantic_lanes: usize,
    pub max_deterministic_lanes_per_slice: usize,
    pub max_semantic_lanes_per_slice: usize,
    pub slice_deterministic_envelope: Duration,
    pub slice_semantic_envelope: Duration,
}

Cross-slice scheduling configuration.

The fairness scheduler enforces three orthogonal limits on top of the existing per-predicate hard timeouts:

1. Global lane caps (max_deterministic_lanes, max_semantic_lanes) bound how many predicates of each kind may run concurrently across all queued slices. Deterministic and semantic lanes are independent so deterministic work continues to make progress while semantic predicates wait for cheap-judge slots.
2. Per-slice lane caps (max_deterministic_lanes_per_slice, max_semantic_lanes_per_slice) keep one slice from monopolizing all global lanes. With the default semantic-per-slice cap of 1, two slices each holding a permit alternate fairly through the global semantic semaphore (FIFO under tokio).
3. Aggregate per-slice envelopes (slice_deterministic_envelope, slice_semantic_envelope) bound the total wall-clock spent on each kind within one slice. Once exhausted, every remaining predicate of that kind for that slice short-circuits to a structured budget_exceeded block — never a panic and never an implicit approval.

Fields

max_deterministic_lanes: usize

Global cap on concurrent deterministic predicate evaluations across all slices.

max_semantic_lanes: usize

Global cap on concurrent semantic predicate evaluations across all slices.

max_deterministic_lanes_per_slice: usize

Per-slice cap on concurrent deterministic predicate evaluations.

max_semantic_lanes_per_slice: usize

Per-slice cap on concurrent semantic predicate evaluations. Keep this strictly less than max_semantic_lanes to enforce fairness when more than one slice is queued.

slice_deterministic_envelope: Duration

Aggregate wall-clock envelope summed across all deterministic predicate attempts for one slice. Both the first attempt and the replay attempt of a deterministic predicate count against this envelope. Setting this to Duration::ZERO disables aggregate enforcement and falls back to the per-predicate hard timeout alone.

slice_semantic_envelope: Duration

Aggregate wall-clock envelope summed across all semantic predicate attempts for one slice. Duration::ZERO disables aggregate enforcement.

Trait Implementations

impl Clone for PredicateSchedulerConfig

fn clone(&self) -> PredicateSchedulerConfig

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PredicateSchedulerConfig

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

Formats the value using the given formatter.

impl Default for PredicateSchedulerConfig

fn default() -> Self

Returns the “default value” for a type.