//! Concurrent user contexts with shared private state and separate call buffers.

export mod abi;

export mod sys;

/// Completed allocation transactions, indexed by the executing hart.

export static count: [u64; 8] = [0; 8];

/// Future budget handles assigned to callers on the preceding online hart.

export static windows: [u64; 8] = [0; 8];

/// Capability used to notify the shared domain from each online hart.

export static notification: u64 = 0;

/// Shared-domain capability for the injected physical interrupt source.

export static interrupt: u64 = 0;

/// Observed destination hart plus one after each context changes budget.

export static migrations: [u64; 8] = [0; 8];

/// Progress shared with the machine fixture for waits and interrupted allocation.

export static wakeState: u64 = 0;

/// Nonzero selects the independently activated idle-wakeup context.

export static idle: u64 = 0;

/// Check hart identity and shared-table allocation through repeated direct calls.

fn run(hart: u64) {

    let source = sys::queryInterrupt(abi::Handle(interrupt));

    assert source.number == 7;

    let original = sys::currentContext();

    assert original.hart == hart;

    let budget = abi::Handle(windows[hart as u32]);

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

    let right = try! sys::budgetSplit(budget, before.start + 1000);

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

    let rightInfo = try! sys::queryBudget(right);

    assert leftInfo.start == before.start and leftInfo.end == rightInfo.start;

    assert rightInfo.end == before.end and rightInfo.hart == before.hart;

    let merged = try! sys::budgetMerge(budget, right);

    assert merged == budget;

    let after = try! sys::queryBudget(merged);

    assert after.start == before.start and after.end == before.end;

    try! sys::capabilityDrop(merged);

    try! sys::wakeup(abi::Handle(notification), hart as u32);

    for i in 0..16 {

        let page = try! sys::pageAllocate(abi::Handle(0), 1);

        let info = sys::queryPage(page);

        assert info.count == 1 and info.base <> 0;

        try! sys::capabilityDrop(page);

        let current = sys::currentContext();

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

        set count[hart as u32] += 1;

    }

    while true {

        let current = sys::currentContext();

        assert current.context == original.context;

        if current.budget <> original.budget {

            set migrations[hart as u32] = current.hart + 1;

        }

    }

}

/// Start an additional context with its physical hart index in validated memory.

export fn worker(args: *u64, size: u64) {

    assert size == 8;

    run(*args);

}

/// The initial context owns hart zero's window.

@default fn main(env: *opaque) {

    if idle <> 0 {

        set wakeState = 2;

        sys::wait();

        set wakeState = 3;

        while wakeState <> 4 {

        }

        set wakeState = 5;

        sys::wait();

        set wakeState = 6;

        while wakeState <> 7 {

        }

        set wakeState = 8;

        sys::wait();

        set wakeState = 9;

        while wakeState <> 10 {

        }

        set wakeState = 11;

        let allocation = try! sys::pageAllocate(abi::Handle(0), 4096);

        set wakeState = 12;

        while true {

        }

    }

    run(0);

}