Files
R8Forge/tests/byte_op_test.cc
T
dsh c2cd0e827f clb_divmod: shift-and-restore division instead of repeated subtraction
Repeated subtraction ran N/D rounds and hit the 5M step ceiling for D = 1
(2047/1 hangs outright); it also cost 2.46M steps for 2047/2.  Binary long
division is fixed at _CELL_SIZE rounds whatever the operands are:

    R = 0 ; Q = 0
    repeat _CELL_SIZE:  R = (R << 1) | next bit   (rol N hands the bits out
                                                   MSB first and restores N
                                                   after W rounds)
                        if R >= D:  R -= D ; quotient bit = 1

The one non obvious part is the comparison.  R needs W+1 bits after the shift,
but the high bit (H, the bit rol wraps out of Rlo) only has to decide the
commit: H = 1 means R >= 2^W > D, so commit = H | Bo, where Bo is raw_sub's "no
borrow" (Rlo >= D).  SPEC 14's Shi = H & Bo is always 0 under the invariant "R
< D at the start of every round" (H = 1 and Bo = 1 together would need R >= 2D),
so that clb_bit_and and its copy do not exist in the built version.

Signature is now clb_divmod N D Q R S: N and D survive, Q and R each get their
own cell (the old version ate N into the remainder), and S is a 7 cell scratch
block (Rhi, Sd, Bo, Cm, Ci, buf, NR).  Only S+5 (the copy buffer) has to be
clean on entry; the rest is rewritten or used as a single bit, which is what
lets clb_digits pass the same dirty block back in every round.

The order that cost clb_mul two reworks is the delicate bit: rol Rlo wraps its
top bit into bit 0, so clb_bit_mov has to move that bit into Rhi (which also
clears it) before bit_copy injects N's bit.  bit_copy (not clb_bit_mov) is what
keeps N intact.

Measured on drv/divmod.r8asm (11 bit):

              repeated subtraction     shift-and-restore
    2047/10        495,986                 28,593
    2047/2       2,461,650                 31,997
    999/7          340,086                 28,661
    2047/1         HANG (>5M)              32,383

Small N/D get slower (fixed W rounds) -- the same trade clb_mul made.  Worst
case over the sweep is 32,383 steps; the tape grows 4189 -> 4499 characters.

About the numbers in SPEC 14 / AGENTS: the 1.48M steps claimed there do not
reproduce on this tree.  Measured before the change, 2047/10 was 495,986 and
clb_digits(2047) was 740,695, so the docs now carry the measured values and say
where the old figure came from.

clb_digits keeps its shape (one divmod in a 4 round loop, written digits shift
up by one cell), with S grown to 13 cells: TEN, quotient, remainder, the 7
divmod scratch cells, the loop counter and add_ip's T/F.  2047 goes from
740,695 to 145,138 steps (worst 164,867) and 10829 -> 13717 characters.  It
needs its own %include "asm/add_ip.r8asm" now: that used to arrive through the
old divmod.

Tests: test_divmod sweeps 8 divisors x all 2048 dividends (16384 pairs; the old
76 sample table is a subset) and also asserts N and D come back unchanged;
test_digits sweeps all 2048 values.  Both print the worst step count.

Two traps found on the way:

* r8forge_derive (and byte_op_test/synth_test) checked the assembler error flag
  before export_rot8(), but an unknown macro or a bad .tp target is found while
  the tree is *expanded*: a missing %include left a truncated tape that still
  ran and printed a plausible wrong answer (all four digits came out '0').  All
  three now check after the export.
* raw_sub's comment claimed Bo = 1 means A < B; the code (and clb_sub_nc) mean
  A >= B.  Comment fixed, behaviour untouched.

Also adds drv/div_shift.r8asm, the single step check for the cross cell shift
plus injection, and records the measurements in SPEC 7.6/7.7/14 and AGENTS.
2026-11-07 22:22:03 +08:00

630 lines
22 KiB
C++

// Runs the byte level library macros over every input pair on a ROT-8 machine.
//
// r8forge_byte_op_test [repo root]
//
// The machine below follows the reference implementation in ROT-8-viz
// (src/rot8.c): `biz` jumps when the LOW BIT of the cell is 0 and `rnz` jumps
// back when it is 1, so `set_0` (= [-]) clears the low bit of whatever is in
// the cell. Reading `[`/`]` as a Brainfuck style "is the cell zero" test makes
// every one of these programs look like an endless loop -- which is exactly the
// mistake three interpreters in this repo used to make.
#include "r8forge/r8asm.hh"
#include <cstdint>
#include <cstdlib>
#include <iostream>
#include <string>
#include <vector>
namespace {
// The cell width is a knob (geometry.hh), so every expectation below is
// written in terms of it instead of in terms of a byte: kCellMod is one past
// the largest value a cell holds. The sweeps walk the first 256 values, which
// is a sample of the cell range rather than all of it.
constexpr int kCellSize = int(kDefaultCellSize);
constexpr int kCellMod = 1 << kCellSize;
constexpr int kCellMask = int(kDefaultCellMask);
struct machine {
std::vector<uint16_t> cells = std::vector<uint16_t>(kDefaultMemoryCells, 0);
std::vector<uint16_t> out;
size_t dp = 0;
size_t steps = 0;
bool finished = true; // false: the step limit ran out
static uint16_t ror(uint16_t v) {
return uint16_t((v >> 1) | ((v & 1u) << (kDefaultCellSize - 1)));
}
void run(const std::string &tape, size_t limit) {
for (size_t pc = 0; pc < tape.size(); pc++) {
if (++steps > limit) {
finished = false;
return;
}
switch (tape[pc]) {
case '>':
dp = (dp + 1) % cells.size();
break;
case '<':
dp = (dp + cells.size() - 1) % cells.size();
break;
case '-': // flb
cells[dp] ^= 1;
break;
case '+': // ror
cells[dp] = ror(cells[dp]);
break;
case '[': // biz: branch when the low bit is zero
if ((cells[dp] & 1) == 0) {
int depth = 1;
while (depth) {
pc++;
if (tape[pc] == '[')
depth++;
else if (tape[pc] == ']')
depth--;
}
}
break;
case ']': // rnz: return when the low bit is one
if ((cells[dp] & 1) == 1) {
int depth = 1;
while (depth) {
pc--;
if (tape[pc] == ']')
depth++;
else if (tape[pc] == '[')
depth--;
}
}
break;
case '.':
out.push_back(cells[dp]);
break;
default: // ',' (input) is not modelled
break;
}
}
}
};
// The expansion (export_rot8) is where an unknown macro or a bad '.tp' target
// is found, so the error flag has to be checked after it: a truncated tape
// still runs, and produces a plausible looking wrong answer.
std::string assemble(const std::string &file) {
r8asm assembler;
if (!assembler.import_file(file, kDefaultCellSize)) {
std::cerr << "could not assemble " << file << "\n";
std::exit(1);
}
std::string tape = assembler.export_rot8();
if (assembler.failed()) {
std::cerr << "could not assemble " << file << "\n";
std::exit(1);
}
return tape;
}
int failures = 0;
void report(const std::string &name, int a, int b, const machine &m,
const std::string &want) {
if (failures++ < 5) {
std::cerr << " WRONG " << name << " a=" << a << " b=" << b << " out";
for (uint16_t v : m.out)
std::cerr << " " << int(v);
std::cerr << " want " << want << " finished=" << m.finished
<< " steps=" << m.steps << "\n";
}
}
// raw_and / raw_or / raw_xor: both operands are preserved, the result is third.
int test_bitop(const std::string &file, const char *name, int op) {
const std::string tape = assemble(file);
std::cout << name << ": " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.cells[2] = uint16_t(b); // B
m.run(tape, 100'000);
const int want = op == 0 ? (a & b) : op == 1 ? (a | b) : (a ^ b);
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == a &&
m.out[1] == b && m.out[2] == want;
if (!ok) {
bad++;
if (bad <= 3)
report(name, a, b, m,
std::to_string(a) + " " + std::to_string(b) + " " +
std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// raw_add: out is A, B, Ci, S, Co.
int test_add(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "raw_add: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(a);
m.cells[2] = uint16_t(b);
m.run(tape, 100'000);
const int sum = a + b;
const bool ok = m.finished && m.out.size() == 5 && m.out[0] == a &&
m.out[1] == b && m.out[2] == 0 &&
m.out[3] == (sum & kCellMask) && m.out[4] == (sum >> kCellSize);
if (!ok) {
bad++;
if (bad <= 3)
report("raw_add", a, b, m,
std::to_string(a) + " " + std::to_string(b) + " 0 " +
std::to_string(sum & kCellMask) + " " +
std::to_string(sum >> kCellSize));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// raw_inc: out is A, Ci, S, Co; S = A + Ci.
int test_inc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "raw_inc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int ci = 0; ci < 2; ci++) {
machine m;
m.cells[0] = uint16_t(a);
m.cells[2] = uint16_t(ci);
m.run(tape, 100'000);
const int sum = a + ci;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == a &&
m.out[1] == ci && m.out[2] == (sum & kCellMask) &&
m.out[3] == (sum >> kCellSize);
if (!ok) {
bad++;
if (bad <= 3)
report("raw_inc", a, ci, m,
std::to_string(a) + " " + std::to_string(ci) + " " +
std::to_string(sum & kCellMask) + " " +
std::to_string(sum >> kCellSize));
}
}
std::cout << " " << (bad ? "FAILED" : "all 512 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_add_nc: out is A, B, S, Ci. This one eats both operands, so A and B have
// to come back zero -- that is what lets it use the 4 cell slice.
int test_add_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_add_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.cells[2] = uint16_t(b); // B
m.run(tape, 100'000);
const int sum = a + b;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == 0 &&
m.out[1] == 0 && m.out[2] == (sum & kCellMask) &&
m.out[3] == (sum >> kCellSize);
if (!ok) {
bad++;
if (bad <= 3)
report("clb_add_nc", a, b, m,
"0 0 " + std::to_string(sum & kCellMask) + " " +
std::to_string(sum >> kCellSize));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_inc_nc: out is A, S, Ci.
int test_inc_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_inc_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int sum = a + 1;
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == (sum & kCellMask) && m.out[2] == (sum >> kCellSize);
if (!ok) {
bad++;
if (bad <= 3)
report("clb_inc_nc", a, 1, m,
"0 " + std::to_string(sum & kCellMask) + " " +
std::to_string(sum >> kCellSize));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_neg_nc: out is A, S, Ci; S = -A, A is eaten.
int test_neg_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int neg = (kCellMod - a) & kCellMask;
const int carry = a == 0 ? 1 : 0; // -0 is 0 but it does carry out
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == neg && m.out[2] == carry;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_nc", a, 0, m,
"0 " + std::to_string(neg) + " " + std::to_string(carry));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_sub_nc: out is A, B, S, Ci; S = A - B and Ci = 1 means no borrow.
int test_sub_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_sub_nc: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.cells[2] = uint16_t(b); // B
m.run(tape, 100'000);
const int diff = (a - b) & kDefaultCellMask;
const int no_borrow = a >= b ? 1 : 0;
const bool ok = m.finished && m.out.size() == 4 && m.out[0] == 0 &&
m.out[1] == 0 && m.out[2] == diff && m.out[3] == no_borrow;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_sub_nc", a, b, m,
"0 0 " + std::to_string(diff) + " " +
std::to_string(no_borrow));
}
}
std::cout << " " << (bad ? "FAILED" : "all 65536 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// Same macro with its carry in at 0 is the ones' complement: S = ~A.
int test_not_nc(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_nc (carry 0): " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int inv = (~a) & kDefaultCellMask;
const bool ok = m.finished && m.out.size() == 3 && m.out[0] == 0 &&
m.out[1] == inv && m.out[2] == 0;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_nc/0", a, 0, m, "0 " + std::to_string(inv) + " 0");
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_not_ip: the ones' complement done in place, one cell, no carry.
int test_not_ip(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_not_ip: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int inv = (~a) & kDefaultCellMask;
const bool ok =
m.finished && m.out.size() == 1 && m.out[0] == inv;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_not_ip", a, 0, m, std::to_string(inv));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_inc_ip: A = A + 1, both in place and in two cells.
int test_inc_ip(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_inc_ip: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int want = (a + 1) & kDefaultCellMask;
const bool ok = m.finished && m.out.size() == 1 && m.out[0] == want &&
m.cells[1] == 0; // the counter cell is spent
if (!ok) {
bad++;
if (bad <= 3)
report("clb_inc_ip", a, 0, m, std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_neg_ip: A = -A, in place, two cells.
int test_neg_ip(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_neg_ip: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.run(tape, 100'000);
const int want = (kCellMod - a) & kCellMask;
const bool ok = m.finished && m.out.size() == 1 && m.out[0] == want;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_neg_ip", a, 0, m, std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_dec_ip: A = A - 1, in place.
int test_dec_ip(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_dec_ip: " << tape.size() << " characters\n";
int bad = 0;
for (int a = 0; a < 256; a++) {
machine m;
m.cells[0] = uint16_t(a);
m.run(tape, 100'000);
const int want = (a - 1) & kDefaultCellMask;
const bool ok = m.finished && m.out.size() == 1 && m.out[0] == want;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_dec_ip", a, 0, m, std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_nonzero: F = (B != 0), B untouched.
int test_nonzero(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_nonzero: " << tape.size() << " characters\n";
int bad = 0;
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(b); // B
m.run(tape, 100'000);
const bool ok = m.finished && m.out.size() == 2 && m.out[0] == b &&
m.out[1] == (b != 0 ? 1 : 0);
if (!ok) {
bad++;
if (bad <= 3)
report("clb_nonzero", b, 0, m,
std::to_string(b) + " " + std::to_string(b != 0 ? 1 : 0));
}
}
std::cout << " " << (bad ? "FAILED" : "all 256 combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_ones: B = 2^A - 1, i.e. A consecutive ones from the low bit, A is eaten.
// Only A <= cell width is in the contract, so that is the whole domain.
int test_ones(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_ones: " << tape.size() << " characters\n";
int bad = 0, n = 0;
for (int a = 0; a <= kCellSize; a++) {
machine m;
m.cells[0] = uint16_t(a); // A, the count
m.run(tape, 5'000'000);
n++;
const int want = (1 << a) - 1;
const bool ok = m.finished && m.out.size() == 2 && m.out[0] == 0 &&
m.out[1] == want;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_ones", a, 0, m, std::to_string(want));
}
}
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " counts ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_divmod: Q = N div D, R = N mod D, and N and D come back unchanged. Shift
// and restore, so the loop runs _CELL_SIZE times whatever N and D are -- the
// repeated subtraction this replaced ran N/D times and crossed the 5M step
// budget outright for D = 1, so it could only be sampled. Now every dividend
// can be swept for a spread of divisors, and the divisor set is a superset of
// the old sampled table's.
int test_divmod(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_divmod: " << tape.size() << " characters\n";
const int divs[] = {1, 2, 3, 7, 10, 100, 1000, 2047};
int bad = 0, n = 0;
size_t worst = 0;
for (int d : divs)
for (int a = 0; a < kCellMod; a++) {
machine m;
m.cells[0] = uint16_t(a); // N
m.cells[1] = uint16_t(d); // D
m.run(tape, 5'000'000);
n++;
if (m.steps > worst) worst = m.steps;
const bool ok = m.finished && m.out.size() == 2 && m.out[0] == a / d &&
m.out[1] == a % d && m.cells[0] == a && m.cells[1] == d;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_divmod", a, d, m,
std::to_string(a / d) + " " + std::to_string(a % d));
}
}
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " pairs ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "")
<< " (worst " << worst << " steps)\n";
return bad;
}
// clb_digits: the value becomes four ASCII digits, most significant first. The
// divmod underneath is now O(_CELL_SIZE) instead of O(N/10), so the whole cell
// range fits in the budget: every value is swept.
int test_digits(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_digits: " << tape.size() << " characters\n";
int bad = 0, n = 0;
size_t worst = 0;
for (int v = 0; v < kCellMod; v++) {
machine m;
m.cells[0] = uint16_t(v);
m.run(tape, 5'000'000);
n++;
if (m.steps > worst) worst = m.steps;
std::string want = std::to_string(v);
while (want.size() < 4) want.insert(want.begin(), '0');
bool ok = m.finished && m.out.size() == 4;
for (int i = 0; ok && i < 4; i++) {
ok = m.out[size_t(i)] == (uint16_t)(unsigned char)want[size_t(i)];
}
if (!ok) {
bad++;
if (bad <= 3) report("clb_digits", v, 0, m, want);
}
}
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " values ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "")
<< " (worst " << worst << " steps)\n";
return bad;
}
// clb_add_ip: A = A + B in place, B is eaten. The loop runs B times, so this
// one is sampled rather than exhaustive -- 256 addends x 8 accumulators.
int test_add_ip(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_add_ip: " << tape.size() << " characters (sampled)\n";
const int accs[] = {0, 1, 5, 127, 128, 200, 254, 255};
int bad = 0, n = 0;
for (int a : accs)
for (int b = 0; b < 256; b++) {
machine m;
m.cells[0] = uint16_t(a); // A
m.cells[1] = uint16_t(b); // B
m.run(tape, 5'000'000);
n++;
const int want = (a + b) & kDefaultCellMask;
const bool ok = m.finished && m.out.size() == 2 && m.out[0] == want &&
m.out[1] == 0;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_add_ip", a, b, m, std::to_string(want) + " 0");
}
}
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " sampled combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
// clb_mul: (PH:PL) = MC * MUL, MC preserved. Shift and add: the loop runs
// once per bit of MUL whatever MUL's value is, so the classic 8 bit domain can
// be swept exhaustively. (The repeated addition version this replaced looped
// MUL times, so it could only be sampled -- and it hit the step limit outright
// for large multipliers.)
int test_mul(const std::string &file) {
const std::string tape = assemble(file);
std::cout << "clb_mul: " << tape.size() << " characters\n";
int bad = 0, n = 0;
for (int mc = 0; mc < 256; mc++)
for (int mu = 0; mu < 256; mu++) {
machine m;
m.cells[0] = uint16_t(mc); // MC
m.cells[1] = uint16_t(mu); // MUL
m.run(tape, 5'000'000);
n++;
const int p = mc * mu;
const bool ok = m.finished && m.out.size() == 3 &&
m.out[0] == (p & kCellMask) && m.out[1] == ((p >> kCellSize) & kCellMask) &&
m.out[2] == mc;
if (!ok) {
bad++;
if (bad <= 3)
report("clb_mul", mc, mu, m,
std::to_string(p & kCellMask) + " " + std::to_string((p >> kCellSize) & kCellMask) +
" " + std::to_string(mc));
}
}
std::cout << " " << (bad ? "FAILED" : "all " + std::to_string(n) + " combinations ok")
<< (bad ? " (" + std::to_string(bad) + " wrong)" : "") << "\n";
return bad;
}
} // namespace
int main(int argc, char **argv) {
const std::string root = argc > 1 ? argv[1] : ".";
const std::string drv = root + "/drv/";
const int bad = test_add(drv + "raw_add_byte.r8asm") +
test_bitop(drv + "raw_and_byte.r8asm", "raw_and", 0) +
test_bitop(drv + "raw_or_byte.r8asm", "raw_or", 1) +
test_bitop(drv + "raw_xor_byte.r8asm", "raw_xor", 2) +
test_inc(drv + "raw_inc_byte.r8asm") +
test_add_nc(drv + "raw_add_nc_byte.r8asm") +
test_inc_nc(drv + "raw_inc_nc_byte.r8asm") +
test_neg_nc(drv + "raw_neg_nc_byte.r8asm") +
test_not_nc(drv + "raw_not_nc_byte.r8asm") +
test_not_ip(drv + "not_ip_byte.r8asm") +
test_inc_ip(drv + "inc_ip_byte.r8asm") +
test_neg_ip(drv + "neg_ip_byte.r8asm") +
test_dec_ip(drv + "dec_ip_byte.r8asm") +
test_nonzero(drv + "nonzero_byte.r8asm") +
test_ones(drv + "ones.r8asm") +
test_divmod(drv + "divmod.r8asm") +
test_digits(drv + "digits.r8asm") +
test_add_ip(drv + "add_ip_byte.r8asm") +
test_mul(drv + "mul_byte.r8asm") +
test_sub_nc(drv + "raw_sub_nc_byte.r8asm");
std::cout << (bad ? "FAILED\n" : "byte level library ok\n");
return bad ? 1 : 0;
}