trident/benches/harnesses/std/compiler/pipeline.tri

program pipeline_bench

// End-to-end benchmark: source bytes → lex → parse → typecheck → codegen → optimize.
// Uses the self-hosted pipeline module to compile a small Trident program,
// then asserts token count, node count, error count, and TIR op count match
// expected values from the Rust compiler.
use vm.io.io

use vm.io.mem

use vm.core.convert

use std.compiler.pipeline

fn main() {
    // Read pipeline state block parameters from public input
    let state_base: Field = io.read()
    let src_base: Field = io.read()
    let src_len: Field = io.read()
    let scratch_base: Field = io.read()
    let expected_tir_count: Field = io.read()
    let expected_err_count: Field = io.read()

    // Initialize pipeline state block (12 words at state_base)
    // +0  src_base
    mem.write(state_base, src_base)
    // +1  src_len
    mem.write(state_base + 1, src_len)
    // +2  out_tir_base (written by compile)
    mem.write(state_base + 2, 0)
    // +3  out_tir_count (written by compile)
    mem.write(state_base + 3, 0)
    // +4  file_kind: 1 = program
    mem.write(state_base + 4, 1)
    // +5  digest_width: 5
    mem.write(state_base + 5, 5)
    // +6  hash_rate: 10
    mem.write(state_base + 6, 10)
    // +7  xfield_width: 3
    mem.write(state_base + 7, 3)
    // +8  max_stack_depth: 16
    mem.write(state_base + 8, 16)
    // +9  spill_ram_base: 2^30
    mem.write(state_base + 9, 1073741824)
    // +10 scratch_base
    mem.write(state_base + 10, scratch_base)
    // +11 err_count (written by compile)
    mem.write(state_base + 11, 0)

    // Load source bytes from public input into RAM
    let src_len_u32: U32 = convert.as_u32(src_len)
    for i in 0..src_len_u32 bounded 2048 {
        let idx: Field = convert.as_field(i)
        let byte: Field = io.read()
        mem.write(src_base + idx, byte)
    }

    // Run the full pipeline: lex → parse → typecheck → codegen → optimize
    pipeline.compile(state_base)

    // Read results
    let tir_count: Field = pipeline.result_tir_count(state_base)
    let err_count: Field = pipeline.result_err_count(state_base)

    // Assert results match Rust compiler reference
    assert(err_count == expected_err_count)
    assert(tir_count == expected_tir_count)

    // Output counts as proof of work
    io.write(tir_count)
    io.write(err_count)
}