vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use std::time::{Duration, Instant};

use crate::task_slab::TaskKey;
use vthread_stack::ParkToken;

use super::{ExpiredTimer, TimerQueue};

fn expiry(task: TaskKey, token: ParkToken) -> ExpiredTimer {
    ExpiredTimer { task, token }
}

#[test]
fn deadlines_are_returned_in_monotonic_order() {
    let now = Instant::now();
    let early = ParkToken::new(1, 1);
    let late = ParkToken::new(2, 1);
    let early_task = TaskKey::owned(1);
    let late_task = TaskKey::owned(2);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(late_task, late, now + Duration::from_secs(2)));
    assert!(timers.schedule(early_task, early, now + Duration::from_secs(1)));

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(1)));
    assert_eq!(
        timers.pop_expired(now + Duration::from_millis(1500)),
        vec![expiry(early_task, early)]
    );
    assert_eq!(timers.active_count(), 1);
    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(3)),
        vec![expiry(late_task, late)]
    );
}

#[test]
fn cancellation_removes_the_earliest_deadline() {
    let now = Instant::now();
    let cancelled = ParkToken::new(1, 1);
    let active = ParkToken::new(2, 1);
    let task = TaskKey::owned(0);
    let mut timers = TimerQueue::new();
    timers.schedule(task, cancelled, now + Duration::from_secs(1));
    timers.schedule(task, active, now + Duration::from_secs(2));
    assert!(timers.cancel(cancelled));

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(2)));
    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(3)),
        vec![expiry(task, active)]
    );
    assert_eq!(timers.active_count(), 0);
}

#[test]
fn cancellation_releases_storage_behind_a_live_earlier_deadline() {
    let now = Instant::now();
    let early = ParkToken::new(1, 1);
    let task = TaskKey::owned(0);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(task, early, now + Duration::from_secs(1)));

    for generation in 1..=256 {
        let later = ParkToken::new(2, generation);
        assert!(timers.schedule(task, later, now + Duration::from_secs(60)));
        assert!(timers.cancel(later));
    }

    assert_eq!(timers.next_deadline(), Some(now + Duration::from_secs(1)));
    assert_eq!(timers.active_count(), 1);
    assert_eq!(
        timers.deadlines.len(),
        1,
        "cancelled entries must not accumulate"
    );
    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(60)),
        vec![expiry(task, early)]
    );
}

#[test]
fn duplicate_registration_preserves_the_original_deadline() {
    let now = Instant::now();
    let token = ParkToken::new(1, 1);
    let task = TaskKey::owned(0);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(task, token, now + Duration::from_secs(1)));
    assert!(!timers.schedule(task, token, now + Duration::from_secs(2)));

    assert_eq!(
        timers.pop_expired(now + Duration::from_secs(1)),
        vec![expiry(task, token)]
    );
    assert!(timers.pop_expired(now + Duration::from_secs(2)).is_empty());
    assert_eq!(timers.active_count(), 0);
}

#[test]
fn cancellation_is_exact_for_tokens_sharing_a_deadline() {
    let now = Instant::now();
    let old = ParkToken::new(1, 1);
    let current = ParkToken::new(1, 2);
    let other = ParkToken::new(2, 1);
    let old_task = TaskKey::owned(0);
    let current_task = TaskKey::owned(1);
    let other_task = TaskKey::borrowed(0);
    let mut timers = TimerQueue::new();
    assert!(timers.schedule(old_task, old, now));
    assert!(timers.schedule(current_task, current, now));
    assert!(timers.schedule(other_task, other, now));
    assert!(timers.cancel(old));
    assert!(!timers.cancel(old));

    assert_eq!(
        timers.pop_expired(now),
        vec![expiry(current_task, current), expiry(other_task, other)]
    );
    assert_eq!(timers.active_count(), 0);
    assert_eq!(timers.next_deadline(), None);
}

#[test]
fn duplicate_registration_cannot_replace_the_original_route() {
    let now = Instant::now();
    let token = ParkToken::new(1, 1);
    let original = TaskKey::owned(7);
    let stale = TaskKey::borrowed(7);
    let mut timers = TimerQueue::new();

    assert!(timers.schedule(original, token, now));
    assert!(!timers.schedule(stale, token, now));
    assert_eq!(timers.pop_expired(now), vec![expiry(original, token)]);
}