vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::SchedulerProfile;
use crate::{CarrierId, CarrierStatus, Runtime, TaskFailure, control::Shared, kernel::Kernel};
use std::sync::Arc;

#[test]
fn receive_bins_distinguish_empty_drains_from_window_deferrals() {
    let mut profile = SchedulerProfile::default();
    let sizes = [0, 1, 2, 3, 4, 7, 8, 15, 16, 31, 32, 63, 64, 128];
    for size in sizes {
        profile.record_receive(Some(size));
    }
    profile.record_receive(None);
    core::assert_eq!(profile.receive_calls(), 15);
    core::assert_eq!(profile.window_deferrals(), 1);
    core::assert_eq!(profile.batch_histogram(), [1, 1, 2, 2, 2, 2, 2, 2]);
    core::assert_eq!(profile.remote_packets(), sizes.iter().sum::<usize>() as u64);
}

#[test]
fn idle_counts_separate_progress_polling_and_wait_calls() {
    let mut profile = SchedulerProfile::default();
    for mounts in [0, 4, 4, 12] {
        profile.record_idle(mounts);
    }
    profile.record_early_work();
    profile.record_poll(3, true);
    profile.record_poll(640, false);
    profile.record_wait(false);
    profile.record_wait_return(true);
    profile.record_wait(true);
    profile.record_wait_return(false);
    core::assert_eq!(profile.idle_entries(), 4);
    core::assert_eq!(profile.idle_dispatches(), 12);
    core::assert_eq!(profile.maximum_idle_dispatches(), 8);
    core::assert_eq!(profile.empty_idle_entries(), 2);
    core::assert_eq!(profile.early_work_returns(), 1);
    core::assert_eq!(profile.poll_episodes(), 2);
    core::assert_eq!(profile.poll_probes(), 643);
    core::assert_eq!(profile.poll_hits(), 1);
    core::assert_eq!(profile.wait_calls(), 2);
    core::assert_eq!(profile.timed_wait_calls(), 1);
    core::assert_eq!(profile.returns_without_task_work(), 1);
}

fn shared(carriers: usize, capacity: usize) -> Arc<Shared> {
    let config = Runtime::builder()
        .carriers(carriers)
        .max_vthreads(capacity)
        .carrier_queue_capacity(capacity)
        .stack_cache_capacity(capacity)
        .build()
        .unwrap()
        .config();
    Arc::new(Shared::new(config))
}

#[test]
fn real_receive_counts_and_publishes_bounded_batches() {
    let shared = shared(1, 65);
    let scope = shared.begin_scope().unwrap();
    for _ in 0..65 {
        shared.submit(scope, "queued".into(), || ()).unwrap();
    }
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    core::assert!(kernel.receive());
    core::assert!(kernel.receive());
    core::assert_eq!(kernel.scheduler_profile.remote_packets(), 64);
    core::assert_eq!(kernel.scheduler_profile.window_deferrals(), 1);
    for _ in 0..32 {
        core::assert!(kernel.tick(false).unwrap());
    }
    core::assert!(!kernel.receive());
    let profile = kernel.scheduler_profile;
    core::assert_eq!(profile.receive_calls(), 3);
    core::assert_eq!(profile.remote_packets(), 65);
    core::assert_eq!(profile.batch_histogram(), [0, 1, 0, 0, 0, 0, 0, 1]);
    kernel.publish(CarrierStatus::Running);
    core::assert_eq!(shared.snapshot().carriers()[0].scheduler_profile(), profile);
    kernel.abort(None, TaskFailure::RuntimeStopped);
    shared.finish_scope(scope);
}

#[test]
fn a_changed_epoch_records_one_poll_probe_without_a_wait() {
    let shared = shared(2, 2);
    let mut kernel = Kernel::new(Arc::clone(&shared), CarrierId(0));
    let observed = kernel.inbox.signal.version();
    kernel.inbox.signal.notify();
    kernel.wait_for_work(observed);
    let profile = kernel.scheduler_profile;
    core::assert_eq!(profile.idle_entries(), 1);
    core::assert_eq!(profile.empty_idle_entries(), 1);
    core::assert_eq!(profile.poll_episodes(), 1);
    core::assert_eq!(profile.poll_probes(), 1);
    core::assert_eq!(profile.poll_hits(), 1);
    core::assert_eq!(profile.wait_calls(), 0);
}

#[test]
fn a_due_timer_records_a_wait_call_without_claiming_a_native_sleep() {
    use crate::task_slab::TaskKey;
    use std::time::Instant;
    use vthread_stack::ParkToken;

    let shared = shared(2, 2);
    let mut kernel = Kernel::new(shared, CarrierId(0));
    let token = ParkToken::new(1, 1);
    core::assert!(
        kernel
            .timers
            .schedule(TaskKey::owned(0), token, Instant::now())
    );
    kernel.wait_for_work(kernel.inbox.signal.version());
    let profile = kernel.scheduler_profile;
    core::assert_eq!(profile.poll_episodes(), 0);
    core::assert_eq!(profile.wait_calls(), 1);
    core::assert_eq!(profile.timed_wait_calls(), 1);
    core::assert_eq!(profile.returns_without_task_work(), 1);
    core::assert!(kernel.timers.cancel(token));
}