.githooks/
compiler/
kernel/
lib/
scripts/
seed/
sublime/
test/
boot/
bootstrap/
compiler/
cycles/
dispatch/
format/
host/
integration/
kernel/
loader/
manifests/
mmio/
native/
packages/
runtime/
scheduling/
root.rad
2.6 KiB
scheduler.rad
2.8 KiB
shared/
slots/
smp/
std/
sync/
termination/
tests/
trap/
verify/
Makefile
9.2 KiB
kernel.rad
776 B
runner.rad
11.6 KiB
vim/
.gitignore
333 B
.gitsigners
224 B
AGENTS.md
8.3 KiB
CONTRIBUTING
2.1 KiB
LICENSE
1.1 KiB
Makefile
2.5 KiB
README
3.4 KiB
STYLE
3.2 KiB
std.lib
2.1 KiB
std.lib.test
1.1 KiB
test/scheduling/scheduler.rad
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 | } |