Struct Scheduler 

pub struct Scheduler { /* private fields */ }

Scheduler state.

Implementations

impl Scheduler

pub fn new(policy: SchedPolicy) -> Self

Create a scheduler with the given policy.

pub fn add_ready(&mut self, coro_id: usize)

Register a coroutine as ready.

pub fn mark_blocked(&mut self, coro_id: usize, reason: BlockReason)

Mark a coroutine as blocked.

pub fn mark_done(&mut self, coro_id: usize)

Mark a coroutine as done (remove from all queues).

pub fn unblock(&mut self, coro_id: usize)

Unblock a coroutine (move from blocked to ready).

impl Scheduler

pub fn schedule(&mut self) -> Option<usize>

Pick the next coroutine to execute, or None if none are ready.

pub fn schedule_with<F>(&mut self, has_progress: F) -> Option<usize>

where F: Fn(usize) -> bool,

Pick the next coroutine using a progress predicate.

pub fn pick_runnable<F>(&mut self, has_progress: F) -> Option<usize>

where F: Fn(usize) -> bool,

Lean-aligned scheduler pick entrypoint.

pub fn pick_eligible_runnable<F>(&mut self, has_progress: F) -> Option<usize>

where F: Fn(usize) -> bool + Copy,

Pick the next runnable coroutine restricted to cached ready eligibility.

pub fn update_after_step(&mut self, coro_id: usize, update: StepUpdate)

Lean-aligned scheduler state transition helper.

pub fn reschedule(&mut self, coro_id: usize)

Re-enqueue a coroutine that yielded or completed an instruction.

pub fn is_ready(&self, coro_id: usize) -> bool

Return whether a coroutine is currently in the global ready set.

pub fn ready_count(&self) -> usize

Number of ready coroutines.

pub fn ready_snapshot(&self) -> Vec<usize>

Snapshot of the current global ready queue order.

pub fn ready_set_snapshot(&self) -> BTreeSet<usize>

Snapshot of current ready coroutine IDs as a set.

pub fn any_ready<F>(&self, predicate: F) -> bool

where F: FnMut(usize) -> bool,

Return whether any ready coroutine satisfies predicate.

pub fn blocked_count(&self) -> usize

Number of blocked coroutines.

pub fn is_stuck(&self) -> bool

Whether all coroutines are either done or blocked (no progress possible).

pub fn step_count(&self) -> usize

Total steps executed.

pub fn policy(&self) -> &SchedPolicy

Current policy.

pub fn timeslice(&self) -> usize

Configured timeslice.

pub fn block_reason(&self, coro_id: usize) -> Option<&BlockReason>

Get the block reason for a coroutine, if blocked.

pub fn blocked_ids(&self) -> Vec<usize>

All blocked coroutine IDs.

pub fn blocked_snapshot(&self) -> BTreeMap<usize, BlockReason>

Snapshot of blocked coroutine reasons.

pub fn has_eligible_ready(&self) -> bool

Whether any coroutine is currently cached as both ready and eligible.

pub fn set_ready_eligibility( &mut self, coro_id: usize, eligibility: ReadyEligibility, )

Update cached ready eligibility for a coroutine.

pub fn clear_ready_eligibility(&mut self)

Clear all cached ready eligibility state.

pub fn assign_lane(&mut self, coro_id: usize, lane: LaneId)

Assign a coroutine to a specific lane.

pub fn lane_of(&self, coro_id: usize) -> Option<LaneId>

Lane assignment for a coroutine.

pub fn lane_queues_snapshot(&self) -> BTreeMap<LaneId, Vec<usize>>

Snapshot of per-lane ready queues.

pub fn lane_blocked_snapshot( &self, ) -> BTreeMap<LaneId, BTreeMap<usize, BlockReason>>

Snapshot of per-lane blocked coroutines.

pub fn record_cross_lane_handoff( &mut self, from_coro: usize, to_coro: usize, reason: impl Into<String>, )

Record a cross-lane handoff.

pub fn cross_lane_handoffs(&self) -> &[CrossLaneHandoff]

Cross-lane handoff log.

Trait Implementations

impl Debug for Scheduler

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Scheduler

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Scheduler

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.