Enum YieldReason 

pub enum YieldReason {
    BudgetExceeded,
    Ring0Priority,
    QueueEmpty,
    ShutdownRequested,
    Interrupted,
    CheckpointBarrier,
    Backpressure,
    FairScheduling,
}

Reason Ring 1 yielded control.

Ring 1 background tasks cooperatively yield to ensure Ring 0 hot path operations are not delayed. This enum captures why the yield occurred for metrics and debugging.

Example

use laminar_core::budget::{TaskBudget, YieldReason};

fn process_background_work(&mut self) -> YieldReason {
    let budget = TaskBudget::ring1_chunk();

    while !budget.exceeded() {
        // Check if Ring 0 needs attention (priority)
        if self.ring0_has_pending() {
            return YieldReason::Ring0Priority;
        }

        // Get next work item
        match self.background_queue.pop() {
            Some(work) => self.process_work_item(work),
            None => return YieldReason::QueueEmpty,
        }
    }

    YieldReason::BudgetExceeded
}

Variants

BudgetExceeded

Budget exceeded, need to give Ring 0 a chance.

The Ring 1 task has used its entire time budget (typically 1ms) and must yield to avoid blocking Ring 0 operations.

Ring0Priority

Ring 0 has pending events (priority yield).

Even if budget remains, Ring 0 events take priority over Ring 1 background work. This ensures latency SLAs.

QueueEmpty

No more work in queue.

The background work queue is empty. The task can sleep or wait for new work to arrive.

ShutdownRequested

Shutdown has been requested.

The task should stop processing and allow graceful shutdown.

Interrupted

External interrupt (e.g., signal).

An external event has interrupted processing.

CheckpointBarrier

Yielded to allow checkpoint coordination.

During checkpointing, tasks may need to yield to ensure consistent state snapshots.

Backpressure

Yielded due to backpressure.

Downstream cannot accept more outputs, so the task yields to avoid buffering too much data.

FairScheduling

Yielded to allow other Ring 1 tasks to run.

Fair scheduling among multiple Ring 1 tasks.

Implementations

impl YieldReason

pub fn should_stop(&self) -> bool

Returns true if this yield reason indicates the task should stop.

pub fn has_more_work(&self) -> bool

Returns true if this yield reason indicates work is available.

pub fn can_resume_immediately(&self) -> bool

Returns true if the task can immediately resume after yield.

pub fn is_ring0_priority(&self) -> bool

Returns true if this yield is due to Ring 0 priority.

pub fn is_budget_related(&self) -> bool

Returns true if this yield is due to budget constraints.

pub fn metric_label(&self) -> &'static str

Get metric label for this yield reason.

Trait Implementations

impl Clone for YieldReason

fn clone(&self) -> YieldReason

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for YieldReason

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

Formats the value using the given formatter.

impl Display for YieldReason

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

Formats the value using the given formatter.

impl Hash for YieldReason

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 YieldReason

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for YieldReason

impl Eq for YieldReason

impl StructuralPartialEq for YieldReason