test/scheduling/scheduler.rad 2.8 KiB raw
1
//! User-space scheduling and CPU-window retirement checks.
2
export mod abi;
3
export mod sys;
4
export mod mmio;
5
6
/// Completion value for a successful scheduling test.
7
constant FINISH_PASS: u32 = 0x5555;
8
9
/// Run a worker, or distribute four successive CPU windows from the boot bundle and
10
/// then let more windows expire than the kernel has budget objects.
11
@default fn main(env: *abi::Env) -> ! {
12
    if env.argsSize == 0 {
13
        sys::exit(7);
14
    }
15
    assert env.argsSize == @sizeOf(abi::BootInfo) as u64;
16
    let records = try! sys::bootInfo(abi::Handle(env.args));
17
    assert records.len == 1;
18
    let info = records[0];
19
    let self = abi::Handle(info.handles[0]);
20
    let started = mmio::read64(info.clock, 0);
21
    assert sys::queryDomain(self).state == 1;
22
    // Boot authority has no end, so the scheduler can run for the life of the system.
23
    let initial = try! sys::queryContext(abi::Handle(0), abi::CURRENT_CONTEXT);
24
    let boot = try! sys::queryBudget(abi::Handle(initial.budget));
25
    assert boot.end == 0xffffffffffffffff;
26
    for turn in 0 .. 4 {
27
        let current = try! sys::queryContext(abi::Handle(0), abi::CURRENT_CONTEXT);
28
        let budget = abi::Handle(current.budget);
29
        let window = try! sys::queryBudget(budget);
30
        let later = try! sys::budgetSplit(budget, window.start + info.timebase);
31
        let worker = try! sys::domainCreate(self, info.schedulerImage);
32
        let stack = try! sys::pageAllocate(self, 16);
33
        let transferred = try! sys::capabilityTransfer(stack, worker, abi::RIGHTS_MASK as u64);
34
        // A worker gets no arguments and exits before reading its Env's argument fields.
35
        try! sys::domainActivate(worker, transferred, abi::Handle(0), 0);
36
        try! sys::yield(worker);
37
        assert (try! sys::queryContext(abi::Handle(0), abi::CURRENT_CONTEXT)).budget == *later;
38
    }
39
    // The kernel retires each window when it ends and leaves its handle stale, so
40
    // more successive windows than its 512 budget objects run to completion.
41
    for turn in 0 .. 513 {
42
        let ending = abi::Handle(
43
            (try! sys::queryContext(abi::Handle(0), abi::CURRENT_CONTEXT)).budget
44
        );
45
        // Leave 100 milliseconds for syscall admission and concurrent timer work.
46
        let end = mmio::read64(info.clock, 0) + info.timebase / 10;
47
        let next = try! sys::budgetSplit(ending, end);
48
        while (try! sys::queryContext(abi::Handle(0), abi::CURRENT_CONTEXT)).budget <> *next {}
49
        let mut stale = false;
50
        try sys::queryBudget(ending) catch err {
51
            assert err == abi::Error::BadHandle;
52
            set stale = true;
53
        };
54
        assert stale;
55
    }
56
    assert mmio::read64(info.clock, 0) > started;
57
    if info.shutdown <> abi::Handle(0) {
58
        mmio::write32(info.shutdown, 0, FINISH_PASS);
59
        panic "main: shutdown returned";
60
    }
61
    sys::exit(0);
62
}