rust-kernel / tests / threads.rs

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
//! Preemptive threads: busy-looping threads that never yield still all make
//! progress, because the timer interrupt switches between them.
#![no_std]
#![no_main]
#![feature(custom_test_frameworks)]
#![test_runner(rustbelt::test_runner)]
#![reexport_test_harness_main = "test_main"]

use bootloader::{BootInfo, entry_point};
use core::panic::PanicInfo;
use core::sync::atomic::{AtomicBool, AtomicU64, Ordering};
use rustbelt::interrupts::TICKS;
use rustbelt::thread;

entry_point!(main);

fn main(boot_info: &'static BootInfo) -> ! {
    rustbelt::init();
    rustbelt::init_memory(boot_info);
    rustbelt::init_smp();

    test_main();
    rustbelt::hlt_loop();
}

static COUNT_1: AtomicU64 = AtomicU64::new(0);
static COUNT_2: AtomicU64 = AtomicU64::new(0);
static DONE_2: AtomicBool = AtomicBool::new(false);

/// Never yields, never returns.
fn spinner_1() {
    loop {
        COUNT_1.fetch_add(1, Ordering::Relaxed);
    }
}

/// Never yields, but returns after a while (tests thread exit).
fn spinner_2() {
    for _ in 0..1_000_000 {
        COUNT_2.fetch_add(1, Ordering::Relaxed);
    }
    DONE_2.store(true, Ordering::Relaxed);
}

#[test_case]
fn busy_threads_are_preempted() {
    thread::spawn("spin1", spinner_1);
    thread::spawn("spin2", spinner_2);

    // The main thread busy-waits too (no hlt): if the timer didn't preempt
    // us, the other threads would never run and we'd hit the timeout.
    let deadline = TICKS.load(Ordering::Relaxed) + 18 * 20; // ~20 s
    while !(DONE_2.load(Ordering::Relaxed) && COUNT_1.load(Ordering::Relaxed) > 1000) {
        assert!(TICKS.load(Ordering::Relaxed) < deadline, "threads made no progress");
        core::hint::spin_loop();
    }
    assert_eq!(COUNT_2.load(Ordering::Relaxed), 1_000_000);

    // spinner_2 has exited; spinner_1 must keep running alongside us.
    let before = COUNT_1.load(Ordering::Relaxed);
    let wait_until = TICKS.load(Ordering::Relaxed) + 5;
    while TICKS.load(Ordering::Relaxed) < wait_until {
        core::hint::spin_loop();
    }
    assert!(COUNT_1.load(Ordering::Relaxed) > before, "spinner_1 stopped running");
}

#[panic_handler]
fn panic(info: &PanicInfo) -> ! {
    rustbelt::test_panic_handler(info)
}