//! User-space CPU windows and bounded worker execution.

export mod abi;

export mod sys;

export mod mmio;

/// Scheduler or worker startup values.

record Env: Copy {

    /// Shared resource bundle for the scheduler.

    argsPointer: *abi::BootInfo,

    /// Zero for a worker, or the resource header size for the scheduler.

    argsSize: u64,

    /// Installed event capability.

    eventsHandle: u64,

    /// Shared event-ring address.

    eventsPointer: u64,

}

/// Run a worker or distribute four successive CPU windows from the boot bundle.

@default unsafe fn main(env: *Env) -> ! {

    if env.argsSize == 0 {

        sys::exit(7);

    }

    assert env.argsSize == @sizeOf(abi::BootInfo) as u64;

    let info = env.argsPointer;

    let self = abi::Handle(info.handles[0]);

    let started = mmio::read64(info.clock, 0);

    assert sys::queryDomain(self).state == 1;

    for turn in 0..4 {

        let current = sys::currentContext();

        let budget = abi::Handle(current.budget);

        let window = try! sys::queryBudget(budget);

        let later = try! sys::budgetSplit(budget, window.start + info.timebase);

        let worker = try! sys::domainCreate(self, info.schedulerImage);

        let stack = try! sys::pageAllocate(self, 16);

        let extent = sys::queryPage(stack);

        let transferred = try! sys::capabilityTransfer(stack, worker, abi::RIGHTS_MASK as u64);

        try! sys::domainActivate(worker, extent.base + extent.count * 4096, (&*env) as *unsafe opaque, 0);

        try! sys::yield(worker);

        assert sys::currentContext().budget == *later;

    }

    assert mmio::read64(info.clock, 0) > started;

    if info.shutdown <> abi::Handle(0) {

        mmio::write32(info.shutdown, 0, 0x5555);

        panic "shutdown returned";

    }

    sys::exit(0);

}