//! Concurrent load, spawn, yield, fault, and teardown cycles.

use support;

export mod abi;

export mod sys;

export mod mmio;

/// Ordered shared-memory access boundary for the single event consumer.

@intrinsic fn memoryFence();

/// Controller resources and retained completion metadata.

record Arguments: Copy {

    /// Readable binary worker package.

    source: abi::Handle,

    /// Exact package byte length.

    length: u64,

    /// Read-only clock capability.

    clock: abi::Handle,

    /// Page that owns this argument record.

    page: abi::Handle,

    /// Reserved worker interval in clock ticks.

    quantum: u64,

    /// Shared worker code base reported to the checker.

    codeBase: u64,

    /// Number of fully checked worker lifetimes.

    completed: u64,

}

/// Published event wire record.

record Event: Copy {

    /// Notification kind.

    kind: u16,

    /// Reserved zero bits.

    reserved: u16,

    /// Terminal status or fault code.

    code: u32,

    /// Generation-bearing child identity.

    value: u64,

}

/// Shared single-consumer event ring.

record Ring: Copy {

    /// Published event slots.

    data: [Event; 256],

    /// Consumer progress.

    head: u32,

    /// Producer progress.

    tail: u32,

    /// Ring index mask.

    mask: u32,

}

/// Kernel startup pointers for one controller.

record Env: Copy {

    /// Writable arguments retained by the parent.

    argsPointer: *unsafe mut Arguments,

    /// Argument record byte size.

    argsSize: u64,

    /// Installed event capability.

    eventsHandle: u64,

    /// Shared event-ring pointer.

    eventsPointer: *unsafe mut Ring,

}

/// Repeat publication lookup and private worker lifetimes on this hart.

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

    assert env.argsSize == @sizeOf(Arguments) as u64;

    let mut args = env.argsPointer;

    let initial = sys::currentContext();

    for turn in 0..4 {

        assert support::advance() == turn as u64 + 1;

        let mut image = abi::Handle(0);

        while image == abi::Handle(0) {

            set image = try sys::imageLoad(abi::Handle(0), args.source, 0, args.length) catch error {

                assert error == abi::Error::Busy;

                continue;

            };

        }

        let loaded = try! sys::queryImage(image);

        if turn == 0 { set args.codeBase = loaded.codeBase; }

        assert loaded.codeBase == args.codeBase;

        let child = try! sys::domainCreate(abi::Handle(0), image);

        let identity = sys::queryDomain(child).id;

        let stack = try! sys::pageAllocate(abi::Handle(0), 4);

        let extent = sys::queryPage(stack);

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

        let shared = try! sys::capabilityGrant(args.page, child, abi::READ as u64);

        try! sys::domainActivate(child, extent.base + extent.count * 4096, args as *unsafe opaque, (turn % 2) as u64);

        let current = sys::currentContext();

        assert current.context == initial.context and current.hart == initial.hart;

        let later = try! sys::budgetSplit(abi::Handle(current.budget), mmio::read64(args.clock, 0) + args.quantum);

        try! sys::yield(child);

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

        let mut ring = env.eventsPointer;

        let head = ring.head;

        let tail = ring.tail;

        memoryFence();

        assert head <> tail and ring.mask == 255;

        let event = ring.data[head & ring.mask];

        assert event.value == identity and event.reserved == 0;

        if turn % 2 == 0 { assert event.kind == 4 and event.code == 9; }

        else { assert event.kind == 3 and event.code == 3; }

        memoryFence();

        set ring.head = head + 1;

        try! sys::capabilityDrop(image);

        set args.completed = turn as u64 + 1;

    }

    sys::exit(68);

}