vthread 0.1.0

Bounded carrier-affine virtual threads for Rust
Documentation
use super::super::{ReadyQueue, WAKE_BURST};
use crate::task_slab::TaskKey;

fn queue(normal: usize, wakes: usize, phase: u8) -> ReadyQueue {
    let mut queue = ReadyQueue::new();
    for index in 0..normal {
        queue.push_back(TaskKey::owned(index));
    }
    for index in normal..normal + wakes {
        queue.push_wake(TaskKey::owned(index));
    }
    queue.wake_streak = phase;
    queue
}

#[test]
fn inspection_visits_each_entry_once_and_preserves_retained_lanes() {
    for phase in 0..=WAKE_BURST + 1 {
        for normal in 0..=4 {
            for wakes in 0..=4 {
                for mask in 0..1_usize << (normal + wakes) {
                    let mut queue = queue(normal, wakes, phase);
                    let selected = |task: TaskKey| mask & (1 << task.index()) != 0;
                    let mut expected_normal = queue.normal.clone();
                    expected_normal.retain(|task| !selected(*task));
                    let mut expected_wakes = queue.wakes.clone();
                    expected_wakes.retain(|task| !selected(*task));
                    let mut visits = [0; 8];
                    let mut removed = Vec::new();
                    let mut inspection = queue.inspection();
                    while let Some(task) = queue.remove_matching(&mut inspection, |task| {
                        visits[task.index()] += 1;
                        selected(task)
                    }) {
                        assert!(!removed.contains(&task));
                        removed.push(task);
                        assert_eq!(queue.len() + removed.len(), normal + wakes);
                        assert_eq!(queue.wake_streak, phase);
                    }
                    assert_eq!(visits[..normal + wakes], vec![1; normal + wakes]);
                    assert_eq!(removed.len(), mask.count_ones() as usize);
                    assert_eq!(queue.normal, expected_normal);
                    assert_eq!(queue.wakes, expected_wakes);
                    assert_eq!(queue.wake_streak, phase);
                }
            }
        }
    }
}

#[test]
fn eligible_selection_matches_the_dispatch_policy_without_moving_skipped_entries() {
    for phase in 0..=WAKE_BURST + 1 {
        for normal in 0..=4 {
            for wakes in 0..=4 {
                for mask in 0..1_usize << (normal + wakes) {
                    let mut actual = queue(normal, wakes, phase);
                    let mut reference = queue(normal, wakes, phase);
                    let eligible = |task: TaskKey| mask & (1 << task.index()) != 0;
                    reference.normal.retain(|task| eligible(*task));
                    reference.wakes.retain(|task| eligible(*task));
                    let expected = reference.pop_front();
                    let mut expected_normal = actual.normal.clone();
                    expected_normal.retain(|task| Some(*task) != expected);
                    let mut expected_wakes = actual.wakes.clone();
                    expected_wakes.retain(|task| Some(*task) != expected);
                    let mut visits = [0; 8];

                    let selected = actual.pop_matching(|task| {
                        visits[task.index()] += 1;
                        eligible(task)
                    });

                    assert_eq!(selected, expected);
                    assert!(visits.iter().all(|visits| *visits <= 1));
                    assert_eq!(actual.normal, expected_normal);
                    assert_eq!(actual.wakes, expected_wakes);
                    assert_eq!(
                        actual.wake_streak,
                        if selected.is_some() {
                            reference.wake_streak
                        } else {
                            phase
                        }
                    );
                }
            }
        }
    }
}

#[test]
fn identity_removal_preserves_other_entries_and_cohort_state() {
    for phase in 0..=WAKE_BURST + 1 {
        for index in 0..=8 {
            let mut queue = queue(4, 4, phase);
            let task = TaskKey::owned(index);
            let mut normal = queue.normal.clone();
            normal.retain(|entry| *entry != task);
            let mut wakes = queue.wakes.clone();
            wakes.retain(|entry| *entry != task);

            assert_eq!(queue.remove(task), index < 8);

            assert_eq!(queue.normal, normal);
            assert_eq!(queue.wakes, wakes);
            assert_eq!(queue.wake_streak, phase);
        }
    }
}