dymokomi/luce-kernel
Source of release 0.1.1
0.1.1 / tests / engine / features_checks.lucb
# The engine's features beyond single operations: uniforms, bindings, exec masks, uniform
# and masked control flow, indexed registers, element numbers and host builtins.
func run_uniforms(program: const Program*, count: usize, inputs: const Column[], outputs: const Column[], uniforms: const Uniform[]) -> Fault?!:
let request = Request(count = count, inputs = inputs, outputs = outputs, uniforms = uniforms, threads = 2, chunk = 2)
return try run(program, &request)
test "uniforms take the host's value or their default":
var b = Builder()
let amount = b.uniform_f32("amount", 0.25)
assert(b.uniform_f32("amount", 9.0) == amount)
b.store(b.output("y", 0, .f32), b.binary(.mul, b.input("x", 0, .f32), amount))
var program = try b.finish()
defer program.destroy()
let xs: f32[5] = [1.0, 2.0, 3.0, 4.0, 8.0]
var ys: f32[5]
let inputs = [Column.input_f32("x", xs)]
let outputs = [Column.output_f32("y", ys)]
assert(try run_uniforms(&program, 5, inputs, outputs, no_uniforms()) == none)
assert(ys == [0.25, 0.5, 0.75, 1.0, 2.0])
assert(try run_uniforms(&program, 5, inputs, outputs, [Uniform.f32("amount", 2.0), Uniform.f32("other", 1.0)]) == none)
assert(ys == [2.0, 4.0, 6.0, 8.0, 16.0])
var refused = false
_ = run_uniforms(&program, 5, inputs, outputs, [Uniform.i32("amount", 2)]) catch failure:
refused = failure.code == bad_binding
assert(refused)
assert(program.uniforms().length == 1 and program.uniforms()[0].name == "amount")
test "columns that do not match the plan are refused before anything runs":
var b = Builder()
b.store(b.output("y", 0, .f32), b.input("x", 1, .f32))
var program = try b.finish()
defer program.destroy()
let xs: f32[6] = [1.0, 2.0, 3.0, 4.0, 5.0, 6.0]
let longs: i64[6] = [1, 2, 3, 4, 5, 6]
var ys: f32[3]
let cases: usize = 6
for case in 0..<cases:
var inputs: Column[1] = [Column.input_f32("x", xs, 2)]
var outputs: Column[1] = [Column.output_f32("y", ys)]
var count: usize = 3
match case:
0: inputs[0] = Column.input_f32("z", xs, 2)
1: inputs[0] = Column.input_i64("x", longs, 2)
2: inputs[0] = Column.input_f32("x", xs, 1)
3: count = 4
4: outputs[0] = Column.input_f32("y", ys)
_: outputs[0] = Column.output_f32("w", ys)
var refused = false
_ = run_columns(&program, count, inputs, outputs) catch failure:
refused = failure.code == bad_binding
assert(refused)
assert(try run_columns(&program, 3, [Column.input_f32("x", xs, 2)], [Column.output_f32("y", ys)]) == none)
assert(ys == [2.0, 4.0, 6.0])
test "strided columns, written in place":
var b = Builder()
for k: usize in 0..<3:
b.store(b.output("P", k, .f32), b.binary(.add, b.input("P", k, .f32), b.constant_f32((f32)k)))
var program = try b.finish()
defer program.destroy()
var positions: f32[12] = [0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 2.0, 2.0, 2.0, 3.0, 3.0, 3.0]
assert(try run_columns(&program, 4, [Column.input_f32("P", positions, 3)], [Column.output_f32("P", positions, 3)]) == none)
assert(positions == [0.0, 1.0, 2.0, 1.0, 2.0, 3.0, 2.0, 3.0, 4.0, 3.0, 4.0, 5.0])
test "exec masks guard assignments and stores":
# y = x * 2 where x > 0, else -x; z written only where x > 0.
var b = Builder()
let x = b.input("x", 0, .f32)
let positive = b.compare(.gt, x, b.constant_f32(0.0))
let y = b.copy(x)
let doubled = b.binary(.mul, x, b.constant_f32(2.0))
b.exec(positive)
b.assign(y, doubled)
b.store(b.output("z", 0, .f32), doubled)
b.exec(b.unary(.bnot, positive))
b.assign(y, b.unary(.neg, x))
b.exec_all()
b.store(b.output("y", 0, .f32), y)
var program = try b.finish()
defer program.destroy()
let xs: f32[6] = [1.0, -2.0, 3.0, 0.0, -5.0, 6.0]
var ys: f32[6]
var zs: f32[6] = [9.0, 9.0, 9.0, 9.0, 9.0, 9.0]
assert(try run_columns(&program, 6, [Column.input_f32("x", xs)], [Column.output_f32("y", ys), Column.output_f32("z", zs)]) == none)
assert(ys == [2.0, 2.0, 6.0, -0.0, 5.0, 12.0])
assert(zs == [2.0, 9.0, 6.0, 9.0, 9.0, 12.0])
test "select picks per lane in every size class":
var b = Builder()
let pick = b.input("m", 0, .mask)
b.store(b.output("f", 0, .f32), b.select(pick, b.constant_f32(1.0), b.constant_f32(2.0)))
b.store(b.output("d", 0, .f64), b.select(pick, b.constant_f64(1.0), b.constant_f64(2.0)))
b.store(b.output("k", 0, .mask), b.select(pick, b.constant_mask(false), b.constant_mask(true)))
var program = try b.finish()
defer program.destroy()
let masks: u8[4] = [1, 0, 7, 0]
var floats: f32[4]
var doubles: f64[4]
var flipped: u8[4]
let outputs = [Column.output_f32("f", floats), Column.output_f64("d", doubles), Column.output_mask("k", flipped)]
assert(try run_columns(&program, 4, [Column.input_mask("m", masks)], outputs) == none)
assert(floats == [1.0, 2.0, 1.0, 2.0] and doubles == [1.0, 2.0, 1.0, 2.0] and flipped == [0, 1, 0, 1])
test "a uniform branch is a real jump":
var b = Builder()
let flag = b.uniform_mask("flag", true)
let y = b.copy(b.constant_f32(2.0))
let skip = b.label()
b.jump_if_false(flag, skip)
b.assign(y, b.constant_f32(1.0))
b.bind(skip)
b.store(b.output("y", 0, .f32), y)
var program = try b.finish()
defer program.destroy()
var ys: f32[3]
let outputs = [Column.output_f32("y", ys)]
assert(try run_uniforms(&program, 3, [Column.input_f32("unused", ys)][..<0], outputs, no_uniforms()) == none)
assert(ys == [1.0, 1.0, 1.0])
assert(try run_uniforms(&program, 3, [Column.input_f32("unused", ys)][..<0], outputs, [Uniform.mask("flag", false)]) == none)
assert(ys == [2.0, 2.0, 2.0])
## total = 2 * count, by a loop that runs each lane `count` rounds.
func counting_loop(b: Builder*, count: u16) -> u16:
let slot = b.loop_slot()
let i = b.copy(b.constant_i32(0))
let total = b.copy(b.constant_i32(0))
let top = b.label()
let done = b.label()
b.loop_start(slot)
b.bind(top)
let looping = b.compare(.lt, i, count)
b.jump_if_none(looping, done)
b.exec(looping)
b.assign(i, b.binary(.add, i, b.constant_i32(1)))
b.assign(total, b.binary(.add, total, b.constant_i32(2)))
b.exec_all()
b.loop_step(slot, looping)
b.jump(top)
b.bind(done)
return total
test "a masked loop runs each lane its own number of rounds":
var b = Builder()
b.store(b.output("total", 0, .i32), counting_loop(&b, b.input("count", 0, .i32)))
var program = try b.finish()
defer program.destroy()
let counts: i32[6] = [0, 1, 5, 3, 10, 2]
var totals: i32[6]
assert(try run_columns(&program, 6, [Column.input_i32("count", counts)], [Column.output_i32("total", totals)]) == none)
assert(totals == [0, 2, 10, 6, 20, 4])
test "indexed registers: pick and place":
var b = Builder()
let first = b.vector(.f32, 4)
for k: u16 in 0..<4:
b.emit(.copy, .f32, first + k, b.constant_f32(10.0 * (f32)(k + 1)), 0, 0)
let at = b.input("at", 0, .i64)
let picked = b.pick(first, 4, at)
b.place(first, 4, at, b.constant_f32(-1.0))
b.store(b.output("picked", 0, .f32), picked)
b.store(b.output("after", 0, .f32), b.pick(first, 4, at))
b.store(b.output("last", 0, .f32), first + 3)
var program = try b.finish()
defer program.destroy()
let indices: i64[4] = [0, 3, 2, 3]
var picks: f32[4]
var afters: f32[4]
var lasts: f32[4]
let outputs = [Column.output_f32("picked", picks), Column.output_f32("after", afters), Column.output_f32("last", lasts)]
assert(try run_columns(&program, 4, [Column.input_i64("at", indices)], outputs) == none)
assert(picks == [10.0, 40.0, 30.0, 40.0] and afters == [-1.0, -1.0, -1.0, -1.0])
assert(lasts == [40.0, -1.0, 40.0, -1.0])
test "element numbers in every integer kind":
var b = Builder()
for kind in [Kind.i32, Kind.i64, Kind.u32, Kind.u64]:
b.store(b.output(kind.name(), 0, kind), b.index(kind))
var program = try b.finish()
defer program.destroy()
var a: i32[7]
var c: i64[7]
var d: u32[7]
var e: u64[7]
let outputs = [Column.output_i32("i32", a), Column.output_i64("i64", c), Column.output_u32("u32", d), Column.output_u64("u64", e)]
assert(try run_columns(&program, 7, [Column.input_f32("unused", [0.0])][..<0], outputs) == none)
for at in 0..<7:
assert(a[at] == (i32)at and c[at] == (i64)at and d[at] == (u32)at and e[at] == (u64)at)
func double_lanes(call: Call*):
let values = call.f32_argument(0)
let flags = call.mask_argument(1)
let doubled = call.f32_result(0)
let counts = call.i32_result(1)
for lane in 0..<call.lanes:
doubled[lane] = values[lane] * 2.0
counts[lane] = (i32)(call.first + lane) if flags[lane] != 0 else -1
assert(call.f64_argument(0).length == 0 and call.f32_argument(5).length == 0)
test "host builtins: registry and calls":
var registry = Registry()
defer registry.destroy()
let builtin = Builtin.of("double", [Kind.f32, Kind.mask], [Kind.f32, Kind.i32], double_lanes)
try registry.add(builtin)
var refused = false
registry.add(builtin) catch failure:
refused = failure.code == bad_builtin
assert(refused)
let found = registry.find("double") else trap("registered builtin missing")
assert(registry.find("triple") == none)
var b = Builder()
let results = b.call(found, [b.input("x", 0, .f32), b.input("flag", 0, .mask)])
b.store(b.output("doubled", 0, .f32), results)
b.store(b.output("number", 0, .i32), results + 1)
var program = try b.finish()
defer program.destroy()
let xs: f32[5] = [1.0, 2.0, 3.0, 4.0, 5.0]
let flags: u8[5] = [1, 0, 1, 0, 1]
var doubled: f32[5]
var numbers: i32[5]
let inputs = [Column.input_f32("x", xs), Column.input_mask("flag", flags)]
assert(try run_columns(&program, 5, inputs, [Column.output_f32("doubled", doubled), Column.output_i32("number", numbers)]) == none)
assert(doubled == [2.0, 4.0, 6.0, 8.0, 10.0] and numbers == [0, -1, 2, -1, 4])
test "a lane mask runs only its lanes, which keep their element numbers":
var b = Builder()
let x = b.input("x", 0, .i32)
let quotient = b.binary(.idiv, b.constant_i32(100), x)
b.store(b.output("q", 0, .i32), quotient)
b.exec_all()
b.store(b.output("n", 0, .i32), b.index(.i32))
var program = try b.finish()
defer program.destroy()
let xs: i32[6] = [1, 0, 2, 0, 5, 0]
let active: u8[6] = [1, 0, 1, 0, 1, 0]
var qs: i32[6] = [9, 9, 9, 9, 9, 9]
var ns: i32[6] = [-1, -1, -1, -1, -1, -1]
let request = Request(count = 6, inputs = [Column.input_i32("x", xs)], outputs = [Column.output_i32("q", qs), Column.output_i32("n", ns)], uniforms = no_uniforms(), threads = 2, chunk = 2, active = active)
assert(try run(&program, &request) == none)
assert(qs == [100, 9, 50, 9, 20, 9] and ns == [0, -1, 2, -1, 4, -1])