nx_sha256_perf_test.nx source
↩ module page · 83 lines · 2366 B
1// nx_sha256_perf_test.nx -- bench substrate SHA-256 on a fixed input.
2//
3// Hashes a deterministic 64 KiB buffer N=20 times in a loop, captures
4// in-program wall-clock via sys_clock_gettime_mono (substrate's mono
5// clock). Prints elapsed nanoseconds + N + bytes-per-iteration so a
6// shell wrapper can compute MB/s.
7//
8// Same input + N=20 will run against system sha256sum for honest
9// substrate-vs-incumbent comparison.
10//
11// expect_exit: 0
12//
13// license_tier: ORIGINAL
14
15import "nx_syscalls.nx"
16import "nx_sha256.nx"
17
18const BUF_BYTES: i64 = 65536 // 64 KiB
19const N_ITER: i64 = 20 // 1.25 MiB total work
20
21func _print_i64(label: *u8, label_len: i64, v: i64) -> i64 {
22 sys_write(1, label, label_len)
23 sys_write(1, " " as *u8, 1)
24 let buf: *u8 = sys_mmap(32)
25 var n: i64 = 0
26 if v == 0 { buf[0] = 48; n = 1 }
27 else {
28 var x: i64 = v
29 if x < 0 { buf[0] = 45; n = 1; x = 0 - x }
30 var digits: i64 = 0
31 var tmp: i64 = x
32 while tmp > 0 { tmp = tmp / 10; digits = digits + 1 }
33 var k: i64 = 0
34 while k < digits {
35 let d: i64 = x % 10
36 buf[n + digits - 1 - k] = (48 + d) & 0xff
37 x = x / 10
38 k = k + 1
39 }
40 n = n + digits
41 }
42 buf[n] = 10
43 sys_write(1, buf, n + 1)
44 return 0
45}
46
47func main() -> i64 {
48 // Deterministic 64 KiB buffer: 0x00, 0x01, ..., wrap mod 256.
49 let buf: *u8 = sys_mmap(BUF_BYTES + 16)
50 var i: i64 = 0
51 while i < BUF_BYTES {
52 buf[i] = (i & 0xff) as u8
53 i = i + 1
54 }
55
56 let out: *u8 = sys_mmap(64)
57 let ts0: *i64 = sys_mmap(32) as *i64
58 let ts1: *i64 = sys_mmap(32) as *i64
59
60 // CLOCK_MONOTONIC = 1. RV64 SYS_CLOCK_GETTIME = 113.
61 __syscall(SYS_CLOCK_GETTIME, 1, ts0 as i64, 0, 0, 0, 0)
62
63 var k: i64 = 0
64 while k < N_ITER {
65 sha256_digest(buf, BUF_BYTES, out)
66 k = k + 1
67 }
68
69 __syscall(SYS_CLOCK_GETTIME, 1, ts1 as i64, 0, 0, 0, 0)
70
71 // ts is {sec, nsec}. Compute elapsed_ns = (s1-s0)*1e9 + (n1-n0).
72 let s0: i64 = ts0[0]
73 let n0: i64 = ts0[1]
74 let s1: i64 = ts1[0]
75 let n1: i64 = ts1[1]
76 let elapsed_ns: i64 = (s1 - s0) * 1000000000 + (n1 - n0)
77
78 _print_i64("elapsed_ns" as *u8, 10, elapsed_ns)
79 _print_i64("n_iter" as *u8, 6, N_ITER)
80 _print_i64("bytes_per_iter" as *u8, 14, BUF_BYTES)
81
82 return 0
83}