Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-kernel

Source of release 0.1.2

0.1.2 / tests / suite / bench.lucb

## The Code node's Stage 1 benchmarks over 1M points: each snippet's run (best of five),
## on one thread and on the pool, plus the host's copy of P into the output that a whole
## cook adds. Prints `name<TAB>threads<TAB>milliseconds` lines; tests/bench/run.py builds
## this program with --opt 3 and makes the table.
import memory
import time
from luce_kernel import engine
from luce_kernel.engine import Column, Request, Uniform, Program
import conformance
import lowering
import snippets
from luce_kernel import lower

let points: usize = 1000000

func measure(name: str, program: const Program*, request: const Request*) -> !:
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<5:
        let started = time.now()
        if let fault = try engine.run(program, request):
            print(f"{name} faulted at {fault.lane}")
            return
        let spent = time.since(started)
        if spent < best: best = spent
    print(f"{name}\t{request.threads}\t{(f64)best / 1000000.0}")

pub func run_all() -> !:
    var set = try conformance.Points.make(points)
    defer set.release()
    var wave = try snippets.wave()
    defer wave.destroy()
    var displace = try snippets.displace()
    defer displace.destroy()
    var colors = try snippets.colors()
    defer colors.destroy()
    var empty = try snippets.empty()
    defer empty.destroy()
    let inputs = [Column.input_f32("P", set.positions, 3), Column.input_f32("N", set.normals, 3)]
    let outputs = [Column.output_f32("P", set.written, 3), Column.output_f32("Cd", set.written, 3)]
    let uniforms = [Uniform.f64("time", 0.5)]
    for threads in [(usize)1, 0]:
        let request = Request(count = points, inputs = inputs, outputs = outputs, uniforms = uniforms, threads = threads)
        try measure("wave", &wave, &request)
        try measure("noise displacement", &displace, &request)
        try measure("rand3", &colors, &request)
        try measure("empty", &empty, &request)
    # The same snippets lowered from Base text (only P is an input, so the request differs).
    var room: u8[1024]
    let root = try lowering.make_root(room)
    var host = try lowering.make_host()
    defer host.destroy()
    var compiled_wave = try lowering.compiled_or_trap(root, &host, lowering.no_header, lowering.wave_body)
    defer compiled_wave.destroy()
    var compiled_displace = try lowering.compiled_or_trap(root, &host, lowering.no_header, lowering.displace_body)
    defer compiled_displace.destroy()
    var compiled_colors = try lowering.compiled_or_trap(root, &host, lowering.no_header, lowering.colors_body)
    defer compiled_colors.destroy()
    for threads in [(usize)1, 0]:
        let request = Request(count = points, inputs = inputs, outputs = outputs, uniforms = uniforms, threads = threads)
        try measure("wave, lowered", &compiled_wave.program, &request)
        try measure("noise displacement, lowered", &compiled_displace.program, &request)
        try measure("rand3, lowered", &compiled_colors.program, &request)
    # Check and lower: the helpers snippet (header and body, about 25 lines), best of 20.
    var fastest: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<20:
        let started = time.now()
        var compiled = try lower.compile(root, lowering.run_over_points, lowering.helpers_header, lowering.helpers_body, &host)
        let spent = time.since(started)
        compiled.destroy()
        if spent < fastest: fastest = spent
    print(f"check and lower\t1\t{(f64)fastest / 1000000.0}")
    var best: u64 = 0xFFFFFFFFFFFFFFFF
    for _ in 0..<5:
        let started = time.now()
        memory.copy(set.written, set.positions, set.positions.length)
        let spent = time.since(started)
        if spent < best: best = spent
    print(f"copy of P\t1\t{(f64)best / 1000000.0}")