Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.2

0.1.2 / tests / engine / verify_checks.lucb

# `verify` refuses every program the interpreter could not run safely; `finish` reports it.

## Whether `finish` refuses the builder's program as bad.
func rejected(b: Builder*) -> bool:
    var program = b.finish() catch failure:
        b.destroy()
        return failure.code == bad_program
    program.destroy()
    return false

test "a well-formed program is accepted and listed":
    var b = Builder()
    b.at(3, 5)
    b.store(b.output("y", 0, .f32), b.unary(.sqrt, b.input("x", 0, .f32)))
    var program = try b.finish()
    defer program.destroy()
    assert(program.is_verified() and program.register_count() == 2)
    assert(program.instructions().length == 2 and program.instructions()[0].op == .sqrt)
    let source = program.source(0) else trap("no source")
    assert(source.line == 3 and source.column == 5 and program.source(2) == none)
    assert(program.inputs()[0].name == "x" and program.outputs()[0].name == "y")
    assert(program.kind(1) == .f32 and program.kind(9) == none and Op.sqrt.name() == "sqrt")

test "operands of the wrong kind":
    var b = Builder()
    _ = b.binary(.add, b.input("x", 0, .f32), b.input("n", 0, .i32))
    assert(rejected(&b))
    var c = Builder()
    _ = c.binary(.div, c.input("n", 0, .i32), c.input("m", 0, .i32))
    assert(rejected(&c))
    var d = Builder()
    d.exec(d.input("x", 0, .f32))
    assert(rejected(&d))
    var e = Builder()
    _ = e.convert(e.input("m", 0, .mask), .i32)
    assert(rejected(&e))
    var f = Builder()
    f.store(f.output("y", 0, .f64), f.input("x", 0, .f32))
    assert(rejected(&f))

test "registers that do not exist or overlap":
    var b = Builder()
    b.emit(.copy, .f32, 999, b.input("x", 0, .f32), 0, 0)
    assert(rejected(&b))
    var c = Builder()
    let v = c.vector(.f32, 4)
    for k: u16 in 0..<4: c.emit(.copy, .f32, v + k, c.input("x", 0, .f32), 0, 0)
    c.emit(.normalize, .f32, v + 1, v, 0, 4)
    assert(rejected(&c))
    var d = Builder()
    let w = d.vector(.f32, 4)
    for k: u16 in 0..<4: d.emit(.copy, .f32, w + k, d.input("x", 0, .f32), 0, 0)
    d.emit(.dot, .f32, d.register(.f32), w, w, 5)
    assert(rejected(&d))
    var e = Builder()
    e.store(7, e.input("x", 0, .f32))
    assert(rejected(&e))

test "writes to registers the run fills":
    var b = Builder()
    let x = b.input("x", 0, .f32)
    b.emit(.copy, .f32, x, b.constant_f32(1.0), 0, 0)
    assert(rejected(&b))
    var c = Builder()
    let one = c.constant_f32(1.0)
    c.assign(one, c.input("x", 0, .f32))
    assert(rejected(&c))

test "a register read before it is written on every path":
    var b = Builder()
    let y = b.register(.f32)
    b.store(b.output("y", 0, .f32), y)
    assert(rejected(&b))
    var c = Builder()
    let flag = c.uniform_mask("flag", true)
    let value = c.register(.f32)
    let skip = c.label()
    c.jump_if_false(flag, skip)
    c.emit(.copy, .f32, value, c.constant_f32(1.0), 0, 0)
    c.bind(skip)
    c.store(c.output("y", 0, .f32), value)
    assert(rejected(&c))

test "loops that could spin forever":
    # A back edge with no loop_step before it.
    var b = Builder()
    let top = b.label()
    b.bind(top)
    b.jump(top)
    assert(rejected(&b))
    # A jump straight onto a back edge, skipping its loop_step.
    var c = Builder()
    let slot = c.loop_slot()
    let head = c.label()
    let latch = c.label()
    c.loop_start(slot)
    c.bind(head)
    c.jump(latch)
    c.loop_step(slot, no_register)
    c.bind(latch)
    c.jump(head)
    assert(rejected(&c))
    # A loop that restarts its own count every round.
    var d = Builder()
    let again = d.loop_slot()
    let start = d.label()
    d.bind(start)
    d.loop_start(again)
    d.loop_step(again, no_register)
    d.jump(start)
    assert(rejected(&d))
    # A jump into the middle of a loop.
    var e = Builder()
    let round = e.loop_slot()
    let entry = e.label()
    let middle = e.label()
    e.loop_start(round)
    e.jump(middle)
    e.bind(entry)
    e.exec_all()
    e.bind(middle)
    e.exec_all()
    e.loop_step(round, no_register)
    e.jump(entry)
    assert(rejected(&e))

test "labels and builder mistakes":
    var b = Builder()
    b.jump(b.label())
    assert(rejected(&b))
    var c = Builder()
    let twice = c.label()
    c.bind(twice)
    c.bind(twice)
    assert(c.has_failed() and rejected(&c))
    var d = Builder()
    d.emit(.jump, .mask, 0, 0, 0, 0)
    assert(rejected(&d))
    var e = Builder()
    _ = e.binary(.add, 42, 43)
    assert(rejected(&e))
    var f = Builder()
    _ = f.uniform_f32("a", 1.0)
    _ = f.uniform_i32("a", 1)
    assert(rejected(&f))

test "an unverified program does not run":
    var program = Program()
    defer program.destroy()
    var refused_run = false
    _ = run_columns(&program, 1, no_uniforms_columns(), no_uniforms_columns()) catch failure:
        refused_run = failure.code == bad_program
    assert(refused_run)

func no_uniforms_columns() -> const Column[]:
    var none_given: const Column[]
    return none_given