code wiki / _hdl_build / nx_multsynth_test.nx
`nx_multsynth_test.nx` source

1// nx_multsynth_test.nx -- the team synthesizes a 2x2 MULTIPLIER from gates (Vedic/array
2// multiplier search space) and verifies each output bit EXACTLY over all 16 inputs.
3// Known answer: all 4 output bits synthesized + re-verified -> exit 0.
4
5import "nx_multsynth.nx"
6
7func ms_puts(s: *u8) -> i64 { var n: i64 = 0; while s[n] != (0 as u8) { n = n + 1 } sys_write(1, s, n); return 0 }
8func ms_num(v: i64) -> i64 {
9    let bb: *u8 = sys_mmap(28); var m: i64 = v; if m < 0 { m = 0 - m }
10    let t: *u8 = sys_mmap(28); var k: i64 = 0
11    if m == 0 { t[0] = 48; k = 1 }
12    while m > 0 { t[k] = 48 + (m % 10); m = m / 10; k = k + 1 }
13    var i: i64 = 0; while i < k { bb[i] = t[k - 1 - i]; i = i + 1 }
14    sys_write(1, bb, k); return 0
15}
16func tally(r: *i64, n: i64) -> i64 { var ec: i64 = 0; var i: i64 = 0; while i < n { if r[i] != 1 { if ec == 0 { ec = i + 1 } } i = i + 1 } return ec }
17
18func ms_bit(k: i64, r: *i64, total: *i64) -> i64 {
19    let op: *i64 = sys_mmap(8*16) as *i64; let a: *i64 = sys_mmap(8*16) as *i64; let b: *i64 = sys_mmap(8*16) as *i64
20    let tt: i64 = mult_tt(k)
21    let L: i64 = bl4_find(tt, op, a, b, 7)
22    var ok: i64 = 0; if L >= 0 { if bl4_reeval(op, a, b, L) == tt { ok = 1 } }
23    ms_puts("  p" as *u8); ms_num(k); ms_puts(" (out bit " as *u8); ms_num(k); ms_puts("): " as *u8); ms_num(L); ms_puts(" gates, exact-verified " as *u8); if ok == 1 { ms_puts("OK\n" as *u8) } else { ms_puts("FAIL\n" as *u8) }
24    total[0] = total[0] + L
25    r[k] = ok
26    return 0
27}
28
29func ms_main(r: *i64) -> i64 {
30    ms_puts("=== GATE-LEVEL search space: synthesize a 2x2 MULTIPLIER from gates (Vedic/array), exact-verified ===\n" as *u8)
31    let total: *i64 = sys_mmap(8) as *i64; total[0] = 0
32    ms_bit(0, r, total)
33    ms_bit(1, r, total)
34    ms_bit(2, r, total)
35    ms_bit(3, r, total)
36    ms_puts("----------------------------------------------------------------\n" as *u8)
37    ms_puts(" team synthesized a verified 2x2 multiplier in " as *u8); ms_num(total[0]); ms_puts(" total gates -- a new bits-up search space, no human picked the structure.\n" as *u8)
38    return 4
39}
40
41func main() -> i64 {
42    let r: *i64 = sys_mmap(8 * 8) as *i64
43    let n: i64 = ms_main(r)
44    let ec: i64 = tally(r, n)
45    sys_exit(ec)
46    return ec
47}
nx_multsynth_test.nx source

`nx_multsynth_test.nx` source
