//! Concurrent private package graphs and complete worker resource recovery.

use std::mem;

use kernel::abi;

use kernel::frames;

use kernel::slots;

use kernel::backing;

use kernel::pages;

use kernel::capability;

use kernel::registry;

use kernel::loader;

use kernel::domains;

use kernel::budgets;

use kernel::dispatch;

use kernel::boot;

use kernel::sync;

use kernel::remote;

use kernel::events;

use kernel::devices;

use kernel::platform;

use kernel::invariants;

use kernel::dispatchinput;

/// Bootstrap resource capabilities.

unsafe static TABLE: capability::Table = undefined;

/// Fixture publication barrier.

static READY: u64 = 0;

/// Surviving event consumer.

unsafe static PARENT: abi::Ref = undefined;

/// Controller identities indexed by hart.

unsafe static CHILDREN: [abi::Ref; 8] = undefined;

/// Bootstrap-owned argument page addresses indexed by hart.

static ARGUMENTS: [u64; 8] = [0; 8];

/// Free frames before controller creation.

static FREE: u32 = 0;

/// Reusable page, backing, domain, and context slots before controller creation.

static SLOTS: [u32; 4] = [0; 4];

/// Validated physical page mapping.

fn memory(address: u64) -> *mut u8;

/// Current kernel package-state table.

fn kernelGp() -> u64;

/// Native checker entry.

fn completion() -> u64;

/// Write one diagnostic byte.

fn put(byte: u8);

/// Finish the native fixture.

fn finish();

/// Count reusable frames in short metadata sections.

unsafe fn freeFrames() -> u32 {

    let mut count: u32 = 0;

    let mut first: u32 = 0;

    while first < pages::STORE.backings.pool.count {

        let mut end = first + 128;

        if end > pages::STORE.backings.pool.count { set end = pages::STORE.backings.pool.count; }

        let guard = sync::enter();

        for i in first..end { if frames::available(&pages::STORE.backings.pool, i) { set count += 1; } }

        sync::leave(guard);

        set first = end;

    }

    return count;

}

/// Count reusable object slots after all allocation transactions have stopped.

fn freeSlots(entries: &[slots::Slot]) -> u32 {

    let mut count: u32 = 0;

    let mut first: u32 = 0;

    while first < entries.len {

        let mut end = first + 128;

        if end > entries.len { set end = entries.len; }

        let guard = sync::enter();

        for i in first..end {

            assert entries[i].state <> slots::State::Reserved;

            if entries[i].state == slots::State::Free { set count += 1; }

        }

        sync::leave(guard);

        set first = end;

    }

    return count;

}

/// Read object capacity at the quiescent boundaries of the workload.

unsafe fn capacity() -> [u32; 4] {

    return [freeSlots(&pages::STORE.slots[..]), freeSlots(&pages::STORE.backings.slots[..]),

        freeSlots(&domains::STORE.slots[..]), freeSlots(&domains::STORE.contextSlots[..])];

}

/// Copy one trusted package into bootstrap-owned memory.

unsafe fn input(authority: abi::Handle, bytes: &[u8]) -> abi::Handle {

    let handle = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, (bytes.len as u64 + 4095) / 4096);

    let page = try! pages::get(&pages::STORE, (try! capability::get(&TABLE, handle)).object);

    assert try! mem::copy(@sliceOf(memory(page.base), page.count * 4096), bytes) == bytes.len;

    return handle;

}

/// Publish fixture state before any hart enters dispatch.

export unsafe fn start(last: bool) {

    if last { setup(); sync::storeRelease(&mut READY, 1); }

    while sync::loadAcquire(&READY) == 0 {}

}

/// Prepare one controller per hart and a later surviving checker.

unsafe fn setup() {

    let pending = try! slots::reserve(&mut domains::STORE.slots[..]);

    let owner = try! slots::commit(&mut domains::STORE.slots[..], pending);

    capability::initialize(&mut TABLE, owner);

    try! backing::registerDomain(&mut pages::STORE.backings, owner);

    let authority = try! capability::install(&mut TABLE, capability::Entry {

        kind: abi::Kind::Domain, object: owner, rights: abi::Rights(abi::CREATE | abi::ALLOCATE),

    });

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

    for bytes in [&dispatchinput::support[..], &dispatchinput::spin[..]] {

        let source = input(authority, &bytes[..]);

        set image = try! loader::load(&mut loader::STATE, &mut pages::STORE, &mut registry::STORE, &mut TABLE,

            loader::Request { authority, source, offset: 0, length: bytes.len as u64 });

    }

    let source = input(authority, &dispatchinput::job[..]);

    let parentHandle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

    set PARENT = (try! capability::get(&TABLE, parentHandle)).object;

    let parent = try! domains::get(&domains::STORE, PARENT);

    set domains::STORE.records[PARENT.index].state = domains::Lifecycle::Active;

    let frame = &mut domains::STORE.contexts[parent.initial.index].frame;

    set frame.pc = completion(); set frame.status = 0x1880;

    set frame.registers[2] = domains::STORE.contexts[parent.initial.index].kernelStack.end;

    set frame.registers[3] = kernelGp();

    let mut arguments: [abi::Handle; 8] = undefined;

    let mut handles: [abi::Handle; 8] = undefined;

    let mut contexts: [abi::Ref; 8] = undefined;

    let mut count: u64 = 0;

    for hart in 0..8 {

        if (boot::PLATFORM.harts & (1 << hart)) == 0 { continue; }

        set count += 1;

        set arguments[hart] = try! pages::allocate(&mut pages::STORE, &mut TABLE, authority, 1);

        set ARGUMENTS[hart] = (try! pages::get(&pages::STORE, (try! capability::get(&TABLE, arguments[hart])).object)).base;

    }

    set FREE = freeFrames();

    set SLOTS = capacity();

    for hart in 0..8 {

        if (boot::PLATFORM.harts & (1 << hart)) == 0 { continue; }

        let handle = try! domains::create(&mut domains::STORE, &mut pages::STORE.backings, &registry::STORE, &mut TABLE, authority, image);

        let object = (try! capability::get(&TABLE, handle)).object;

        let mut child = try! domains::get(&domains::STORE, object);

        set CHILDREN[hart] = object; set handles[hart] = handle; set contexts[hart] = child.initial;

        try! domains::reparent(&mut domains::STORE, &TABLE, handle, parentHandle);

        let self = try! capability::install(&mut child.memory.table, capability::Entry {

            kind: abi::Kind::Domain, object, rights: abi::Rights(abi::CREATE | abi::ALLOCATE),

        });

        let stack = try! pages::allocate(&mut pages::STORE, &mut child.memory.table, self, 4);

        let storage = try! pages::get(&pages::STORE, (try! capability::get(&child.memory.table, stack)).object);

        let args = @sliceOf(memory(ARGUMENTS[hart]) as *mut u64, 6);

        set args[0] = *(try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, source, abi::READ as u64));

        set args[1] = dispatchinput::job.len as u64;

        for i in 0..devices::STORE.count {

            if devices::STORE.regions[i].kind == platform::Kind::Clint {

                set args[2] = *(try! devices::install(&devices::STORE, &mut child.memory.table, i));

            }

        }

        assert args[2] <> 0;

        set args[3] = *(try! pages::grant(&mut pages::STORE, &TABLE, &mut child.memory.table, arguments[hart], (abi::READ | abi::WRITE | abi::GRANT) as u64));

        set args[4] = 10000000 * count;

        try! domains::activate(&mut domains::STORE, &pages::STORE, &TABLE, handle, storage.base + storage.count as u64 * 4096, ARGUMENTS[hart], 56);

    }

    for byte in "cycles controllers ready\n" { put(byte); }

    let now = dispatch::clock();

    let start = now + 1000000 * count;

    for hart in 0..8 {

        if (boot::PLATFORM.harts & (1 << hart)) == 0 { continue; }

        let window = try! budgets::seed(&mut budgets::STORE, &mut TABLE, hart, start, 0xffffffffffffffff);

        let tail = try! budgets::split(&mut budgets::STORE, &mut TABLE, window, start + 800000000 * count, now);

        let bound = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

            budgets::Binding { budget: window, domain: handles[hart], context: contexts[hart] }, now);

        if hart == 0 {

            let final = try! budgets::bind(&mut budgets::STORE, &domains::STORE, &mut TABLE,

                budgets::Binding { budget: tail, domain: parentHandle, context: parent.initial }, now);

        }

    }

}

/// Check all terminal records, shared code identity, and complete transient recovery.

export unsafe fn verify() {

    for byte in "cycles checking completion\n" { put(byte); }

    let guard = sync::enter();

    let mut parent = try! domains::get(&domains::STORE, PARENT);

    let job = registry::find(&registry::STORE, &"job"[..]) else panic "worker package required";

    let package = try! registry::get(&registry::STORE, job);

    let mut seen: u64 = 0;

    while let event = try! events::pop(&mut parent.memory.ring) {

        assert event.kind == events::CHILD_EXIT and event.code == 68;

        let mut found = false;

        for hart in 0..8 {

            if (boot::PLATFORM.harts & (1 << hart)) == 0 { continue; }

            if event.value == abi::id(CHILDREN[hart]) {

                assert (seen & (1 << hart)) == 0;

                set seen |= 1 << hart; set found = true;

                let args = @sliceOf(memory(ARGUMENTS[hart]) as *mut u64, 7);

                assert args[5] == package.codeAddress and args[6] == 4;

            }

        }

        assert found;

    }

    assert seen == boot::PLATFORM.harts;

    try! events::refresh(&mut domains::STORE.events, PARENT, &parent.memory.ring);

    assert loader::STATE.live[job.index] and not loader::STATE.busy;

    let retained = loader::STATE.resident[job.index].code.count + loader::STATE.resident[job.index].metadata.count;

    sync::leave(guard);

    let mut done = false;

    for attempt in 0..100000 {

        let guard = sync::enter();

        set done = domains::STORE.dead == 0 and pages::STORE.backings.pool.retiredCount == 0;

        if done { sync::leave(guard); break; }

        let request = try! dispatch::request(0, remote::Action::Reschedule);

        sync::leave(guard);

        assert try! dispatch::awaitRequest(0, request) == 0;

    }

    assert done;

    assert freeFrames() + retained == FREE;

    let recovered = capacity();

    for i in 0..4 { assert recovered[i] == SLOTS[i]; }

    invariants::check(&TABLE);

    for byte in "cycles final recovery and invariants passed\n" { put(byte); }

    let maximum = sync::maximum();

    assert maximum > 0 and maximum < 1000000;

    for byte in "cycles metadata instructions: " { put(byte); }

    number(maximum);

    put(10);

    let waiting = sync::maximumWait();

    assert waiting > 0;

    for byte in "cycles acquisition instructions: " { put(byte); }

    number(waiting);

    put(10);

    finish();

}

/// Write a fixed-width diagnostic value.

fn number(value: u64) {

    let digits = "0123456789abcdef";

    for i in 0..16 { put(digits[((value >> ((15 - i) as u64 * 4)) & 15) as u32]); }

}