94 lines
2.5 KiB
Plaintext
94 lines
2.5 KiB
Plaintext
; Benchmark scaffold fixture for local-machine enum-struct-payload timing
|
|
; comparisons only. Keep LOOP_COUNT and EXPECTED_CHECKSUM aligned with the
|
|
; C/Rust/Python fixtures. The runner supplies the loop count through stdin or
|
|
; argv so native compilers cannot fold the benchmark loop into a constant
|
|
; answer.
|
|
|
|
(module main)
|
|
|
|
(struct Packet
|
|
(digits (array i32 8)))
|
|
|
|
(enum PacketState
|
|
Missing
|
|
(Live Packet)
|
|
(Cached Packet))
|
|
|
|
(fn loop_count () -> i32
|
|
1000000)
|
|
|
|
(fn expected_checksum () -> i32
|
|
3500013)
|
|
|
|
(fn parse_stdin_loop_count () -> (result i32 i32)
|
|
(let input (result string i32) (std.io.read_stdin_result))
|
|
(match input
|
|
((ok text)
|
|
(std.string.parse_i32_result text))
|
|
((err code)
|
|
(err i32 i32 code))))
|
|
|
|
(fn parse_arg_loop_count () -> (result i32 i32)
|
|
(std.string.parse_i32_result (std.process.arg 1)))
|
|
|
|
(fn configured_stdin_loop_count () -> i32
|
|
(let parsed_stdin (result i32 i32) (parse_stdin_loop_count))
|
|
(if (is_ok parsed_stdin)
|
|
(unwrap_ok parsed_stdin)
|
|
(loop_count)))
|
|
|
|
(fn configured_loop_count () -> i32
|
|
(let parsed_arg (result i32 i32) (parse_arg_loop_count))
|
|
(if (is_ok parsed_arg)
|
|
(unwrap_ok parsed_arg)
|
|
(configured_stdin_loop_count)))
|
|
|
|
(fn live_digits () -> (array i32 8)
|
|
(array i32 2 7 1 8 2 8 1 8))
|
|
|
|
(fn cached_digits () -> (array i32 8)
|
|
(array i32 1 6 1 8 0 3 4 5))
|
|
|
|
(fn live_state () -> PacketState
|
|
(PacketState.Live (Packet (digits (live_digits)))))
|
|
|
|
(fn cached_state () -> PacketState
|
|
(PacketState.Cached (Packet (digits (cached_digits)))))
|
|
|
|
(fn select_state ((i i32) (live PacketState) (cached PacketState)) -> PacketState
|
|
(if (= (% i 2) 0)
|
|
live
|
|
cached))
|
|
|
|
(fn state_digit ((state PacketState) (i i32)) -> i32
|
|
(match state
|
|
((PacketState.Missing)
|
|
0)
|
|
((PacketState.Live payload)
|
|
(index (. payload digits) i))
|
|
((PacketState.Cached payload)
|
|
(index (. payload digits) i))))
|
|
|
|
(fn enum_struct_payload_loop ((limit i32)) -> i32
|
|
(let live PacketState (live_state))
|
|
(let cached PacketState (cached_state))
|
|
(var i i32 0)
|
|
(var acc i32 13)
|
|
(while (< i limit)
|
|
(set acc (+ acc (state_digit (select_state i live cached) (% i 8))))
|
|
(set acc (if (> acc 1000000000)
|
|
(- acc 1000000000)
|
|
acc))
|
|
(set i (+ i 1)))
|
|
acc)
|
|
|
|
(fn main () -> i32
|
|
(let result i32 (enum_struct_payload_loop (configured_loop_count)))
|
|
(std.io.print_i32 result)
|
|
(if (= result (expected_checksum))
|
|
0
|
|
1))
|
|
|
|
(test "enum struct payload loop checksum is deterministic"
|
|
(= (enum_struct_payload_loop (loop_count)) (expected_checksum)))
|