Struct PreemptiveResource 

pub struct PreemptiveResource { /* private fields */ }

A cloneable handle to a capacity-limited pool whose held units can be preempted by higher-priority requests.

Like PriorityResource, units are requested at a priority (lower number = higher priority) and blocked waiters are served in priority order. Unlike it, when every unit is in use a higher-priority request does not wait behind the holders — it evicts the lowest-priority holder whose priority is strictly worse than its own, taking that unit immediately.

Preemption is cooperative-at-yield: a higher-priority request fires the victim’s preempted signal, and the victim is expected to bail via any_of![work, guard.preempted()]. A well-behaved holder races its work against that signal:

use simu::{SimEnv, PreemptiveResource, any_of};
let mut env = SimEnv::with_seed(0);
let res = PreemptiveResource::new(1);
let h = env.handle();
let r = res.clone();
env.spawn(async move {
    let guard = r.request(2).await;
    let service = 10.0;
    // Race the service time against a possible preemption.
    any_of![h.timeout(service), guard.preempted()].await;
    if guard.is_preempted() {
        // Higher-priority work took the unit — abandon and clean up.
        return;
    }
    // Completed normally; dropping the guard releases the unit.
});
env.run();

PreemptiveResource wraps an Rc<RefCell<>> internally, so cloning is cheap and all clones share the same pool. It is !Send + !Sync.

Implementations

impl PreemptiveResource

pub fn new(capacity: usize) -> Self

Create a new preemptive resource pool with the given capacity.

Panics

Panics if capacity is zero.

pub fn request(&self, priority: u32) -> PreemptiveRequest

Request one unit at the given priority (lower = higher priority).

Resolves immediately if a unit is free or if a strictly lower-priority holder can be preempted; otherwise suspends in priority order until a unit is released or becomes preemptible.

The returned PreemptiveGuard releases the unit when dropped, and exposes preempted / is_preempted so the holder can yield the unit cooperatively.

pub fn in_use(&self) -> usize

Number of units currently in use.

pub fn capacity(&self) -> usize

Total capacity of this resource pool.

pub fn queue_len(&self) -> usize

Number of processes currently blocked waiting for a unit (i.e. those that could neither take a free unit nor preempt a holder). Excludes abandoned (canceled) requests and current holders.

Trait Implementations

impl Clone for PreemptiveResource

fn clone(&self) -> PreemptiveResource

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PreemptiveResource

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

Formats the value using the given formatter.