a5dfd704998be0cd2a34fc3eb551d224ea1d7533
141
Commits
| Author | SHA1 | Message | Date | |
|---|---|---|---|---|
|
|
a5dfd70499 |
docs: what a mechanical dp can actually mean when the memory is electronic
The question that exposes the gap in the previous note: if the ring lives in a 6116, what is a mechanical pointer pointing at? The honest answer is that dp is an address, so there are three coherent designs and they are different machines. A. a mechanical address register. The physical position of a 64 position device (uniselector, or stepper plus ratchet) feeds A0..A5 of the SRAM through its contact bank. The position is genuinely part of the machine state and the panel pointer does not lie, but it only selects which byte is addressed -- it is not the byte. Cheap (50-200 CNY) and two days of work, so it stays N1. B. a drum. Eight tracks by 64 cells rotating under fixed read and write heads: then the memory itself is mechanical, dp becomes the phase of the rotation, > waits for the next cell pulse, < waits almost a full turn, and + or - does a read-modify-write between two heads one cell apart. Expensive and months of machining, but it is the 1950s machine. C. a magnetostrictive delay line. 512 bits of sound circulating in a loop of nickel wire with a transducer at each end: the ring is literally a loop, there are no bearings and no heads to wear, > is free (wait for the next time slot), < costs at most one revolution (0.5 ms at 1 Mbit/s). An order of magnitude cheaper than the drum and still electrically genuine, but it needs winding, biasing and scope time. Recommendation stays: A first because it is cheap and it is honest about being an address register, then C if the wish is for the memory itself to be mechanical, with B kept for when there must be a spinning drum. The section now says all of this, and the summary table no longer claims dp can simply "be mechanical". |
||
|
|
1e7acc018e |
hardware: the 74LS machine gets a period bill of materials, and a mechanics plan
Two things: the TTL build is now the main target (Tang Nano looks too modern), and the packer learned the format that makes the TTL build simple. Format: r8forge_tape_pack --eprom writes one byte per instruction with the opcode in the low three bits. Then ip is the EPROM address and D2..D0 are the opcode -- no shift register, no 16 bit window, no decoder. It wastes five bits per instruction, and a 27C512 is exactly 64K, which is the historical instruction budget: the 8 bit calculator (51378) and the flagship (43676) both fit. Both formats live in the same .r8t trailer now (format byte 1 = packed, 2 = one byte per instruction), decode dispatches on it, and the test runs both and requires the same output and step count. Carrier: 74LS DIPs on a green board, 27C512 in a socket with its quartz window, 6116 SRAM, 74LS299 for the rotate, 6850 ACIA for serial, 74LS47 and four seven segment displays on the panel, 1 MHz can oscillator. About 31 to 40 chips, 400 to 700 CNY, a few weeks. The FPGA stays as a bench-only stepping stone. hardware/mechanics.md: where mechanics actually pays. The program must stay electronic (130 metres of paper tape for the calculator), and 512 relays for the data ring are out, but the pointer is worth it -- > and < are 71 to 73 percent of all steps, so a 64 position ratchet or uniselector makes the machine physically walk the ring. Also listed: an electromagnetic step counter (10 to 20 Hz, so only in single step mode, with a clutch for free running), a paper tape punch or plotter for output, a tape/card reader or plain keypad for input, and a hand crank as the clock. The rule that keeps this safe: mechanics only ever sit on sensor and actuator pins and never in the logic path, and the handshake just stops the sequencer while something moves -- since nothing in the ISA can observe time, slower is not different. A relay-only machine is priced honestly too: 60 to 120 relays, 10 to 50 Hz, hello in 10 to 40 seconds, the calculator in four hours, so that one is an exhibit. Also fixed: the synthesised macro fallback file name now carries a per-run token. When the system temp directory is not writable every r8asm falls back to the same working directory, so parallel ctest runs could write and import the same file -- which showed up as a random one-test failure in 0.39 seconds and nothing else. |
||
|
|
9b31a51fec |
hardware: M0 -- the packer, the RTL, and a simulator that agrees byte for byte
The two things software cannot check by reading its own source are the 3 bit
packing and the bracket strategy, so both got a tool and a test.
New in the library (r8forge/tape.hh, src/tape.cc): the opcode numbering (taken
from ROT-8-viz enum, so the packed image and the hardware decoder cannot drift),
text <-> opcodes, opcodes <-> 3 bit bytes, the .r8t image with its trailer and
crc32, and a machine model that runs a packed tape the way a board would. The
model takes the bracket strategy as an option: backward scan with loop stack or
not, and jump-back-onto-the-[ (the contract) or past it (what the interpreters
do). All four combinations print the same thing, and the step count differs by
exactly the number of taken ] instructions -- which is what the test asserts.
Found and fixed while writing it: the loop stack discipline depends on the jump
convention. Jumping onto the [ means the [ re-pushes, so ] must pop on the jump;
jumping past it means the entry must stay until the loop exits. Mixing them up
emptied the stack on the second iteration of the calculator main loop -- caught
by the equivalence test on examples/calc.r8asm, not by reading the code.
Tools: r8forge_tape_pack (text tape -> image + --hex for $readmemh + --verify,
727 instructions become 273 bytes for hello, 62%, and the trailer sits past the
halt so address 0 of a ROM is instruction 0), and r8forge_tape_run now reads an
image directly and takes --loop-stack / --retest.
hardware/rot8.v: the 8 bit / 64 cell machine -- 3 bit opcodes from a byte
addressed memory read as a 16 bit window, a 6 bit dp with free wrap, the loop
stack bracket jump, blocking input, halt on ip == length, and a step counter that
counts instructions rather than cycles. hardware/tb_rot8.v loads a --hex image
and prints the OUT stream in tape_run format.
Verified with Icarus Verilog 14 (the RTL against tape_run --loop-stack --retest):
hello 577 instructions 417 steps 10 outs
term 16414 17643 11 (fed "lhi")
calc 51378 166741 19 (fed "12 34 + .": prints the prompt,
046 and the next prompt)
flagship 43676 100142 93
Every OUT stream identical. ctest -R rtl_sim runs that comparison from an 8 bit
build (11 tests in the default build now, where the RTL test self-skips because
the RTL is the 8 bit machine).
Two traps worth remembering: Icarus passes plusargs through as raw bytes, so an
absolute +HEX path containing non-ASCII (this checkout is under a Chinese
directory name) arrives mangled, $readmemh silently leaves the memory empty and
the machine obediently runs LEN steps of opcode 0 printing nothing -- run vvp
from the directory holding the hex with a relative name. And in_ready must not
be qualified with !in_valid or the input handshake deadlocks.
|
||
|
|
0c7d0c8754 |
hardware: the point is Harvard, not "no RAM" -- two ways to hold the program
Restating the constraint correctly: program and data must not share storage. That is already guaranteed by the instruction set, not by wiring -- none of the eight instructions can read or write the program memory, ip only moves by one or by a bracket jump, so there is no self modifying code and no way for data to become instructions. The two also wrap differently: the tape is linear and halts at the end, the data is a ring of 64 cells. Given a strict Harvard split, the program side has two ordinary implementations: * in place ROM: ip is the address of a parallel EEPROM or flash (28C256, 29C010, 39SF010), fifteen to seventeen address lines and eight data lines, no glue logic; the chip in a wide socket is the cartridge and there is no boot step; * on board program RAM plus a one shot load: a separate RAM or block RAM is filled at reset from any small source (serial flash, microSD, UART, even a 24C512) and then executed in place. Swapping tapes no longer means burning a chip; the price is a boot state machine and one more chip. It is still not the data RAM -- only the boot logic can write it, so the Harvard property holds. Both give random access, so the bracket scan question stays about speed only, and the loop stack is still the default because the calculator main loop wraps the whole tape. Media that cannot be addressed at all (mechanical tape, serial only flash, floppy) remain useful as the source for the second variant. |
||
|
|
96ef30304a |
hardware: execute in place -- the machine does not get a program RAM or a loader
The data ring is part of the ISA and cannot go away (64 addressable cells, one 6116 or 512 flip flops), but the program RAM and the loader are not part of the machine: copying the tape into RAM would put another machine inside this one and lose the premise that the tape is the program. So the default architecture is now execute in place: ip is the address of the tape memory, the fetched byte yields three bits of opcode, and the bracket scans are address increments and decrements. That works with a parallel EEPROM or flash (28C256, 29C010, 39SF010): fifteen address lines, eight data lines, no glue logic, and the chip in a socket is the cartridge. On an FPGA the tape is block RAM initialised from the bitstream, which also needs no loading step and no external chip. LOAD then RUN stays in the document only as an optional peripheral for media that cannot be addressed: mechanical tape, serial SPI flash, floppy. One consequence is now stated as a requirement rather than an option: with in place execution a bracket scan costs a clock per instruction, and the calculator main loop wraps almost the whole 51378 instruction tape, so a scanning ] would cost 51 k clocks per round -- 51 ms at 1 MHz, paid on every character read. The loop stack implementation (pop on ], no rescan) is therefore the default, and it is also what makes mechanical media viable at all. The packer output is correspondingly simpler: the .bin is literally the memory contents, ready for a programmer or a block RAM init file. No image layout, no FAT, no loader to write. |
||
|
|
e5a63d0196 |
hardware: the medium only has to fit in a hand -- rank the candidates by size
With LOAD then RUN settled, the medium only has to deliver 19 to 51 KB once, so a floppy is pure overkill and the useful axis is size. Section 9 now ranks the candidates by area: * a DIP-8 EEPROM or SPI flash (24C512, 25Q64) is a 10 mm square in an 8 pin socket -- the ROM cartridge model, no filesystem at all because the chip is the address space, about 3-10 CNY, writable with any CH341A class programmer; * microSD is 15 by 11 mm and holds the whole tape library; the loader reads raw sectors from LBA 0, so no FAT parser is needed either (dd from a PC writes the card); * a credit-card punched card at 2 mm pitch holds about 1000 instructions, which runs hello (577) or full_add (95) but none of the big programs -- good as an art cartridge, not as the main medium; * a microcassette is 50 by 33 by 8 mm, a real small tape, 150 B/s so a 19 KB image loads in two minutes, drives second hand; * the 3.5 inch floppy, 90 by 94 mm, stays only if you want the clack. Both small options also drop the filesystem question: one reads raw blocks, the other is memory. A small AVR can act as the tape drive for a TTL machine behind a DATA/STROBE handshake, and on an FPGA the loader is a few dozen lines. The packer gains --at-lba 0 for the card case and --i2c-image for the programmer case; only the floppy route would need --fat12. |
||
|
|
9d9d64a1d9 |
hardware: LOAD then RUN -- which makes a floppy a perfectly good tape
A mechanical medium is only a bad *execution* memory; real machines loaded from the medium into RAM and ran from there. That decouples the medium speed from the machine: the medium just has to deliver tens of KB/s once, and execution costs no traversal at all. With that architecture a 3.5 inch floppy is fine, and the note now records what is still buyable: USB floppy drives are still made (about 50-120 CNY) but only expose whole 512 byte sectors, so a small microcontroller or a Pi acts as the host and feeds them to the machine; a 34 pin drive plus an N82077AA class controller is the all period correct route and much more work; Gotek style emulators are the reliable but media-less option; audio cassettes are still sold and load the 19 KB image in about two minutes, which is plenty when the program then runs from RAM. A floppy can even be the executing tape: at 300 rpm and 18 sectors per track it streams 46 KB/s, so the 51378 instruction tape goes round in 0.4 s and with the loop stack it only ever streams forward -- but you have to do MFM decoding and sector framing yourself, and every input character waits 0.4 s. LOAD then RUN is an order of magnitude simpler and a hundred times faster. The real floppy risk is not the drive, it is the media: 20 to 30 year old disks grow mould and lose their field, so keep several NOS disks and two copies of each image. The software side is small: a --fat12 disk.img output on the packer, writing HELLO.R8T and CALC.R8T into a standard 1.44 MB image that any USB drive can put on a real disk. |
||
|
|
4f7fa63048 |
hardware: the medium needs +-1 iteration, not random access -- but our loops are long
Correcting an over-specification: ip only ever moves by one, and a bracket scan is made of one-step moves, so any medium that can be iterated forwards and backwards will do. Taking that further, the backward half is removable too: keep a five bit LIFO of loop entry positions, push on [ when the low bit is one, and on ] always pop -- the popped position is the matching [, and if the low bit is one we jump back to it (it re-runs) and otherwise carry on. [ with a zero low bit still scans forward, which it would anyway. That is equivalent to the reference scan for well formed tapes, and since scans do not count as steps the four VMs still agree on step counts. So a forward-only medium can execute directly. What actually rules media out is speed. The runtime loops in our programs are enormous: the calculator main loop wraps almost the whole 51378 instruction tape, so every character read walks the entire tape. A paper tape reader at 50-300 characters per second would need 170-1000 seconds per keystroke; an audio cassette around 130 s; magnetic tape or floppy class (30-500 k chars/s) gives 0.1 to 1.7 s; RAM needs no walk at all. So paper tape is a demo medium (the 577 instruction hello tape is about two seconds), and the practical machine stores the tape in RAM or block RAM. The medium table and this analysis are in section 9, the loop-stack variant in section 4. |
||
|
|
6185f39f34 |
hardware: spell out what the program medium has to satisfy
Nothing is committed to flash yet, so section 9 now records the constraint that decides it: the [ skip scans forward but the ] jump scans backward, so whatever holds the tape must support random access, or the machine has to copy the whole tape into RAM at boot. That is why a serial SPI flash cannot execute directly: it only streams forward. A parallel flash or EEPROM with an address bus can be the tape itself (29C010 at 70-150 ns is comfortable at 1 MHz), and on an FPGA the tape simply lives in block RAM next to the bitstream, no external chip at all. The packed image the taper pack tool will emit is medium independent on purpose: the same bytes initialise block RAM, program an EEPROM and drive the RTL testbench, so M0 does not have to wait for the medium decision. Paper tape stays a demo medium only: at 2.54 mm pitch the 577 instruction hello tape is about 1.5 m, and the calculator tape would be 130 m. |
||
|
|
0c75772cbb |
geometry: the ring size becomes a build option, and the machine takes 64 cells
259 was never part of the machine, just the historical default, so kDefaultMemoryCells is now R8FORGE_MEMORY_CELLS (1..65536, default 259) with a range guard in CMake, the same way the cell width already worked. All five VMs read it from geometry.hh, so nothing else had to change. Measured the highest cell each tape in the tree actually touches by walking its > and < and recording the peak (no tape does a < at cell 0, so none of them depend on wrapping): calc 51, hello 49, signed_demo 34, term 27, and the asm/test.r8asm self test 155, because it lays every macro cell block out side by side. So a 64 cell ring runs every program we ship; only the self test needs the default. Verified: the full ctest suite is 8/8 at both 128 and 64 cells (11 bit); at the hardware geometry of 8 bit plus 64 cells the widthfree label is 5/5, and the calculator tape is byte for byte identical to the 259 cell build and its sessions take the same 166348 steps. The self test also produces identical output at 64 cells but 216 more steps, because its high cells fold back onto low ones -- which is why SPEC section 1.2 states the rule: ring size must be at least the highest cell a program touches plus one. Hardware payoff: at 64 cells dp is a 6 bit counter whose wrap is free, so the TTL build loses its modulo-259 comparator logic (four to five chips), the RAM needs 64 bytes, and the drum shrinks to 8 tracks by 64 cells (at 3000 rpm that is 52 s for a calculator session, so it wants to spin faster). hardware.md is updated to the 8 bit / 64 cell machine throughout. |
||
|
|
d1939a687c |
hardware: the machine is 8 bits, and that fixes the budget too
Decision: the physical machine uses 8 bit cells. 11 bits is half decimal semantics and half superstition; at 8 bits a cell is a byte, so , and . are plain byte I/O, the whole 259 cell ring is 259 bytes and fits one 6116, and the datapath is one 74HC299 plus an XOR. It also settles the instruction pointer problem: the 8 bit calculator is 51378 instructions, back under the historical 65536, where the 11 bit one had grown to 73624 with its terminal front end. Measured tape sizes and step counts at 8 bits (build8, MSVC): full_add 95 instructions, 36 bytes hello 577 instructions, 217 bytes term 16414 instructions, 6.2 KB signed_demo 37511 instructions, 14.1 KB asm/test.r8asm 43676 instructions, 16.4 KB, 99824 steps, 52 OUTs calc 51378 instructions, 19.3 KB, 166348 steps for "12 34 + ." The note now records the 8 bit numbers next to the 11/16/32 ones, recomputes the TTL bill of materials (20-28 chips instead of 25-35: one RAM, one shift register, four or five ip counters), gives the drum 8 tracks instead of 11, and adds an optional M4 that widens the machine back to 11 bits by swapping the ROM to demonstrate that width is a build parameter rather than runtime state. Milestone M2 now expects exactly 99824 steps and M3 expects "046" from the calculator, both of which the software side already produces. |
||
|
|
12a2254078 |
docs: a design note for building the machine out of silicon
docs/hardware.md turns the ISA into hardware requirements and works out what a physical ROT-8 needs. The load-bearing observation is that nothing in the instruction set can observe time -- no counters, no interrupts, and the I/O behaviours are "block until a character" and "latch the cell" -- so any implementation that reproduces the same sequence of (ip, dp, cells, output) is the same machine, at any clock rate and any number of cycles per instruction. That is what makes the build tractable: a microcoded sequencer, slow memory or even a drum are all legal. The note pins the parts that are easy to get wrong: the exact scan boundaries for [ and ] (the ] case jumps back onto the [ itself so it re-tests, which the reference rot8.c gets right and a naive implementation gets wrong), the halt condition, cells starting at zero, and the input convention -- , blocks until a character arrives and an explicit EOF reads as 0, otherwise every interactive read would return zero and the program would exit at once. Budget: 3 bits per instruction, so the flagship tape is 23.4 KB of ROM and the calculator at 11 bits is 27.6 KB; the data ring is 259 cells by W bits at most 518 bytes. Two consequences: the instruction pointer needs at least 17 bits because the calculator now assembles to 73624, past the historical INS_SIZE of 65536, and the 32 bit calculator (126 KB) does not fit the block RAM of the small boards. Three carriers are compared: FPGA first (Tang Nano 9K, about 58 KB of BSRAM, a weekend of work), discrete TTL as the real machine (25-35 chips, 0.25-0.5 M instructions per second, a few weeks) and electromechanical as the showpiece (a drum with 11 tracks and 259 cells per track, read and write heads one cell apart so a read-modify-write costs one cell time: 22 s for a whole calculator session at 3000 rpm). The verification plan leans on what already exists: a packer into the 3 bit format, the RTL testbench compared against tape_run step by step, then the panel single-stepped against an exported trace. Nothing is implemented; the note ends with the decisions that come first -- which carrier, which width (8, 11 or 16), program storage, and whether the physical tape form matters. The first concrete step would be M0: the packer plus a rot8.v testbench, which needs no hardware purchase and gives all three carriers the same golden model. |
||
|
|
1513111689 |
synth: measure whether the address-aware metric can shrink a real program
It cannot. The calculator assembles to 73624 characters in the default flat metric and 73940 with --synth-chars (identity layout), 316 more. Three reasons, now written down in SPEC section 3.7: * the travel term 2*(hi-lo) is translation invariant, so moving a group of cells farther or nearer changes nothing; only a permutation or a spread can, and the contiguous identity layout is already the tightest of those; * the library blocks are expanded at dozens of call sites with different addresses, so a single layout line is a guess that the real sites rarely match; * the model still ignores the hop between blocks, and the exact metric tends to pick programs with more blocks (six blocks for the adder table against five, 82 emitted characters against 87 -- five characters, which the other tables give back and more). Cell placement is the lever that works, and it is already spent: the terminal front end first put its borrowed classifier cells at 52..57 (77164 characters) and moving them into 20..29 gave 73624, minus 3540. Five single-cell moves on the current map were measured too (T and DEPTH to 17, HAVE and CNT to 52, S2 back to 52) and every one is longer: +182, +2900, +92, +134, +3810. So the map is a local optimum and the only way down from 73.6k is to drop features. The experiment left three metric-0 cache entries behind; they were deleted, so the committed cache still holds only what the flat metric needs. |
||
|
|
5c414292d2 |
calc: a terminal front end -- echo, backspace editing and a prompt
The calculator now behaves like the terminal tape from the previous commit:
every character is echoed, backspace edits the digit window, Enter commits the
line and prints the next prompt, and '.' puts its result on its own line:
> 12 34 + .
0046
> 12<BS>3 .
0013
> ^D
It is not the terminal's line buffer moved over: the calculator consumes one
character at a time, and replaying a buffered line would mean unrolling the
engine once per buffer cell, which does not fit. Line editing here is the
digit window: backspace shifts it right by one, pads a '0' in front, echoes
"space, backspace" and keeps accumulating.
Three things had to be learned the hard way, all recorded in docs/calc.md ?8:
* a borrowed constant cell gets eaten. KBS (the 8 that backspace subtracts)
lived in SC+5, and the operator step erases SC..SC+6 wholesale, so the first
byte after an operator was treated as a backspace -- every character of
"12 34 + ." came out as an erase. It is now loaded right before each use.
It also must not borrow R: the EOF test writes R every round.
* set_1 only forces the low bit; cells lent to the classifier have to be
re-initialised each round rather than assumed clean.
* the prompt after Enter has to be printed before the command dispatch and the
operators run, because EH (the "this was Enter" flag) borrows SC+3, which
mul uses as scratch -- the first version printed a prompt after every
multiplication.
The tape went 64983 -> 73624 characters (+8.6k: three copies for the window
shift alone are ~4.4k, the two subtracts ~3k). That is past the old
ROT-8-viz INS_SIZE of 65536; the current VM sizes its buffer from the tape and
runs 112802 characters at 16 bits and 336304 at 32 bits, so only the
historical budget is gone, not the ability to run it. Ducking under 65536
again would mean dropping line editing: echo plus the Enter prompt alone is
about +2.5k, still over.
Verified: ctest 8/8 (examples_test checks the new header stream), the width
matrix at 11, 16 and 32 bits (calc stream, terminal tape and the viz's serial
output all agree; 73624 / 112802 / 336304 characters), and docs/calc.md records
step counts for the whole session list -- "12 34 + ." is 287589 steps, about
17% more than before the front end.
|
||
|
|
d0fd127048 |
build: the 32 bit toolchain builds, and 8/16 bit byte tests really pass
Two separate things hid behind "32 bit works": * tests/byte_op_test.cc could not compile at 32 bits at all (`1 << 32` in a constexpr plus an int typed mask), so the whole 32 bit build stopped there -- only `r8forge` and the core library came out. kCellMod is now clamped at 31+ bits and main() prints "skipped" above 16 bits (every sweep there is 2^W rows) and exits green. All ten targets build at 32 bits with MSVC, and the same tree builds clean on a Gentoo box with GCC 16 -- the missing <cstring> in asm_test.cc that stopped GCC first is in the previous commit. * the digit drivers hardcoded a 4 cell window, so byte_op_test's digits / digits_signed / undigits failed at every other width (16 bits wants 5 digits, 8 bits 3). drv/digits.r8asm, drv/digits_signed.r8asm and drv/undigits_byte.r8asm now derive D = _CELL_SIZE * 30103 / 100000 + 1 and space their cells by it, and the C++ side uses the same kDigits instead of a literal 4 (including the T/F cells clb_digits_signed leaves behind). With that, byte_op_test passes at 8, 11 and 16 bits (the 16 bit run takes about 450 s) and above 16 it skips. Two more width bugs fell out on the way: the divmod divisor sweep used 1000 and 2047 unconditionally (they wrap at 8 bits), and the undigits garbage guard OR'ed in bits above the cell, which at 8 bits turned '0'+digit into a value over 255. test_divmod_signed also divided by the recovered divisor without re-checking it, and at 8 bits the boundary value 1024 wraps to 0 -- that was a hard crash (divide by zero), not a failure. CMakeLists.txt now refuses -DR8FORGE_CELL_SIZE outside 1..32 at configure time; the range used to be a comment, so an out of range width was discovered as a compiler error in whichever file shifted by it first. geometry.hh and SPEC section 13 record that 32 is the ceiling because every VM stores a cell in uint32_t -- going further means widening all five VMs, the assembler's immediate type and ROT-8-viz's rot8_data. Also recorded there: the %synth cache is keyed by the truth table, not the width, so a 32 bit build hits the committed entries (0.4 s for the flagship tape of 227075 characters). A full cold rebuild takes ~500 s on a 44 thread machine, 479 s of which is the single 6 parameter full adder table. |
||
|
|
d2da61a255 |
build: include <cstring> in asm_test.cc
std::strcmp needs it; MSVC pulls it in transitively so the Windows build never noticed, but GCC 16 rejects the file. Found while trying to build a 32 bit toolchain on a Linux box to time the %synth cache. |
||
|
|
c417304140 |
term: a line-editing terminal -- buffer, backspace and command dispatch
examples/term.r8asm was a per-character echo (prompt, echo, backspace erase, newline, EOF). It is now a small shell: a 4 character line buffer, a backspace that really removes a character, and Enter -- or EOF, for a half typed line -- commits the line and dispatches on its first character. 'l' prints the length, 'r' prints the buffer backwards, 'q' quits, anything else is ignored. The header session "lhi" exercises the whole chain: EOF commits the pending line, so examples_test sees the '3'. Three more sessions are documented in the header: "rab" gives NUL+'b'+'a'+'r', "lab<BS>" gives '2' (the backspace really dropped the 'b'), and "lhi<NL>rxy<NL>" prints '3' then the reversed second line. Three things ate most of the debugging time; all three are written up in the file: * "else" needs a flag cell. biz enters when the low bit is set, so "if not A then B" cannot be inferred from "the last test missed": set FLAG=1 before the test, clear it in the matched branch, look at FLAG afterwards. And biz tests the CURRENT dp cell, so the order has to be "set FLAG, then .tp to the condition cell, then biz" -- the wrong order made every character look like a commit key. * clb_sub_nc eats its operands, so the echo and the append both work from the copy CE. The first version appended C (already zeroed by the comparison), which left the line buffer empty: 'l' printed 0 and 'r' printed four NULs. * the cell layout dominates the tape. copy / clb_sub_nc / clb_nonzero all emit .tp internally, some of them inside %rep _CELL_SIZE, so a 20 cell gap costs a couple of thousand characters: putting the constants at 22..28 gave 33067 characters, packing the hot cells into 0..27 gives 21721. The buffer is left aligned with a length counter -- appending needs a dispatch on LEN, but backspace is just LEN-- -- and 'r' prints all four cells instead of dispatching on the length, which costs a NUL for the unused cells and is documented. tests/widths.ps1 now also checks term.r8asm at every width (its expected stream is width independent, which is what makes it a good second program for the matrix), and TODO/AGENTS/README record the item as done. |
||
|
|
4eec72953a |
docs: README -- the calculator is done, the terminal tape is next
The TODO summary line still advertised the interactive calculator; it has been finished (and is now an RPN stack). Point at docs/calc.md and list what is really left: the terminal tape, the mini printf, the tape optimiser, --profile, the cache check and CI. |
||
|
|
0c218abf32 |
calc: a 3 cell RPN stack -- nesting now works
The two register machine (A accumulator + P pending operand) could not nest:
"1 2 + 3 4 * + ." printed 0007 because the second operator overwrote the
first. The calculator now keeps a 3 cell stack (S0 is the top), operators run
immediately (pop two, push one), '.' is a real peek (repeated '.' shows the
same value, and it no longer flushes anything), and ',' clears both the stack
and the depth.
Depth is counted in DEPTH because the unary minus rule needs it: '-' is unary
iff the stack is empty. The previous "the previous character was an operator"
rule is wrong for a stack machine -- in "1 2 + -" the minus has to be a binary
subtraction (popping an empty cell yields 0, and 0 - top is exactly a
negation); treating it as unary would silently swallow the sign. The
"have == 0" rule from the original plan was already wrong for the old machine
("2 * -5" would lose its minus).
Sizing was driven by the tape: every push/pop is one copy per stack cell
(~500 characters), and the file has to stay under 65536. So 3 cells instead
of the 16 the TODO dreamed of: push is two copies (S2<-S1, S1<-S0), an
operator is two more (S1<-S2, then the result), and the new number is written
straight into clb_undigits' target cell (it erases N itself) so the extra
"result -> top" copy disappears -- that one was worth 540 characters. S2 sits
in cell 33, the freed OP cell: putting it at 51 cost 3.7k in walking alone.
64983 characters (was 62624) and 246142 steps for "12 34 + ." (was 280645 --
the old settle-the-pending-OP block is gone). The file header carries the
measured session list, the nesting cases, the stack move order (high to low,
or the source gets overwritten) and the older "2047 3 / ." caveat; docs/calc.md
gets the stack section, and SPEC 5.4/7.10 now point at DEPTH instead of NEED.
|
||
|
|
10f164b480 |
docs: the signed wrappers in SPEC, AGENTS, README and TODO
SPEC gains 7.10 with both contracts, the five design points and the measured tape lengths; 5.4 stops saying "implementation pending" and spells out why the range is asymmetric -- |N| can be outside the signed range while still fitting unsigned, so 1024 has to print -1024 and the absolute value cannot be done by clearing the sign bit. Numbers re-measured on this machine, because some had drifted: the flagship is 62351 characters / 202159 steps (documented as 62513 / 206491), --opt takes it to 56338, the calculator is 62624, the byte level test is 23 items over 22 macros, and asm/ has 55 macros in 23 files. tests/widths.ps1 no longer compares the viz's serial output below 8 bit cells: the viz prints one number per OUT there, so the 7 bit "viz FAILED" was the script's expectation, not the tape -- the calculator itself passes at 7 bits through r8forge_derive, and the same failure reproduces with the previous calculator (checked against HEAD in a temp worktree). The TODO gains the open question of whether the flagship should keep the 65536 limit at all, plus the evidence that a 16 bit tape of 96052 characters runs fine in the viz. |
||
|
|
a30a19690b |
calc: signed display, signed division and a unary minus
'/' now goes through clb_divmod_signed and '.' through clb_digits_signed, so the accumulator can be negative: "3 5 - ." prints "> -0002", "-5 2 * ." prints "> -0010" and "-7 -2 / ." prints "> 0003". Add, subtract and multiply needed nothing -- mod 2^W arithmetic is already two's complement correct. The one new piece of state is NEED, "a new operand is expected": expression start, just settled, just after an operator, just after ','. A '-' with NEED == 1 is unary: set NEG, clear ISCMD (so step 3 leaves OP alone), and the next number is negated in the flush. NEED == 0 means P already holds an operand waiting to be settled, so '-' stays the binary minus. The original plan was "HAVE == 0 means unary", which is wrong: HAVE only says "digits are being accumulated", so after "2 *" it is 0 too and the minus in "2 * -5 ." would be parsed as a subtraction. Two consequences worth knowing: 2047 is now -1, so "2047 3 / ." correctly prints "> 0000" instead of the old unsigned 0682 (write "1023 3 / ." for 341), and the printable range is -1024..1023. The tape grows 59519 -> 62624 characters: the two wrappers plus the NEED/NEG judging. The file header carries the measured sessions with their step counts and the three cells the signed macros needed (T1 48, T2 49, SG 50), and examples_test still checks the "12 34 + ." line. |
||
|
|
1f3f453e88 |
signed: the two two's complement wrappers, with exhaustive sweeps
clb_digits_signed N REG S T F prints '-' (45) and then |N| as the same four zero padded digits; clb_divmod_signed N D Q R S T1 T2 F is the C style truncated division (q = trunc(n/d), r = n - q*d, remainder follows the dividend). Both are wrappers: clb_digits / clb_divmod still do the work, so the tape only grows by the sign handling -- 572 characters for the display (12151 vs 11579 in the same driver layout) and 1191 for the division (6018 vs 4827). The sign bit is read with rol + bit_copy + ror, 49 characters. clb_bit_mov is deliberately NOT used: it eats the source bit, so N comes back as N - HALF and 1024 -- whose magnitude 1024 only fits the unsigned range -- prints as 0000. A clb_sub_nc against a HALF constant was the other candidate: 765 characters for the call plus ~60 for the constant cell. A flag has to outlive the block that consumes it, because biz/rnz only exit once the body clears the condition bit. So sign(N) is moved into T2, sign(D) into F, and the remainder block flips F into sign(N)^sign(D) on its way out; a single conditional negation of the quotient then carries the xor. The negation scratch is S+6: the only cell in S with a "clean on entry" contract, and clb_neg_ip leaves it zero again for clb_divmod. Verified by r8forge_byte_op_test: all 2048 values for the display (worst 117606 steps) and 4202 division pairs -- every |a|,|b| <= 32 plus the 0/+-1/+-1023/+-1024 boundary combinations -- compared against C's / and %. examples/signed_demo.r8asm is the single point regression that runs as a program (the flagship cannot carry them: +12.1k / +5.6k on a 62351 tape). |
||
|
|
723b8285dd |
docs: record the signed number plan in AGENTS, SPEC and TODO
The four decisions are settled and the work is not done, so each fact goes where it
belongs:
SPEC 5.4 two complement, the sign bit is _CELL_SIZE-1 (-1024..1023 at 11 bits,
-128..127 at 8 bits, symmetric, so no |MIN| trap), display -0042,
truncating division (the remainder takes the sign of the dividend),
silent wraparound. Addition, subtraction and multiplication need no
change: the arithmetic is already modulo 2^W.
TODO three independently verifiable steps -- clb_digits_signed (sign test
via clb_sub_nc against HALF = 2^(_CELL_SIZE-1), negate a copy, then the
existing digits), clb_divmod_signed (magnitudes, unsigned divide, signs
reapplied), and the calculator unary minus when HAVE is clear. Each
step lists its acceptance sweep.
AGENTS a short pointer so the next session sees the big queued thing.
The width trap is called out in all three: HALF must be %rep _CELL_SIZE; a literal
11 would misread the sign bit on an 8 bit machine.
|
||
|
|
3ac4ede73d |
AGENTS: the machine semantics are frozen except for INP/OUT
The owner stated the rule plainly: apart from INP/OUT (which are host interface decisions), machine semantics do not change unless explicitly asked -- the eight instructions, biz/rnz testing the LSB, + rotating right, - flipping the low bit, how steps are counted, the 259 cell ring, running from the first instruction to the end of the tape. The reason is that three implementations cross check each other and none of them is a second specification: a "harmless" tweak in one makes the other two look broken, with nothing to adjudicate. Changing semantics means writing it in SPEC first and changing all four machines together (SPEC 13); otherwise only tools and views may change. |
||
|
|
c0e98eb2f4 |
AGENTS: a stale rot8_test.exe looks like a broken tape
The other machine's ROT-8-viz was three commits behind and still had the old serial
INP ("only the low 7 bits change, leave the rest alone"), so the calculator printed
> 0000 there while the same 62800 character tape printed > 0005 in the current
checkout. Recompiling "fixed it by magic" -- it was the whole-cell INP commit.
Worth writing down because the failure mode is deceptive: viz is the authority, so
a stale authority looks like a program bug. The bullet now says to verify the
binary is fresh first, and names the symptom.
|
||
|
|
3543003a78 |
digits: reorder the scratch block -- 22% fewer steps, 15% less tape
The profile said 77% of clb_digits' steps are pointer moves, so the layout of its 13 cell scratch block (S..S+12) is the cost. The block is one rigid 7 cell unit (clb_divmod owns its internal order: Rhi,Sd,Bo,Cm=Bc,Ci,buf,NR) plus six free units, so the legal space is 5040 permutations. All 5040 were assembled and run (minimal driver, value 2047): old: TEN Q R [block] counter T F new: T1 R [block] TEN Q F counter tape 13,717 -> 11,717 chars (-14.6%) steps 145,114 -> 113,264 (-21.9%) pointer moves 111,958 -> 80,108 (-28.4%) non-move steps identical (33,156) Full 2048 value sweep: worst 164,843 -> 123,731 (-24.9%), mean 144,904 -> 112,552 (-22.3%), better on all 2048 values. The old layout ranked 3459/5040. Two things worth remembering. First, ordering the units by the wrapper's first visit order is *worse* than the old layout (150,748 steps): first visit ignores revisit frequency -- the counter is touched once per round, TEN is copied into Bc every round, T1 is hammered by clb_add_ip's carry chain. Second, the n-1 lower bound is not reachable here: 74% of the steps still execute inside clb_divmod's block, whose order is not clb_digits' to choose, so this lever is now exhausted (that is what the exhaustive search proves). Min tape is not min steps either: block-first BQTRT1F1C gives the shortest tape (10,713) but 123,890 steps. Tape counts a .tp once, steps count its execution. Ripple: asm/test.r8asm 64,513 -> 62,513 chars, 236,439 -> 206,491 steps, INS_SIZE headroom ~1k -> ~3k; --opt 58,060 -> 56,350; calc --opt 52,857; calc_op 77,356 -> 69,324 chars / 599,090 -> 476,170 steps. Verified: ctest 8/8, byte_op_test 21 items (digits 2048/2048), examples_test 18, --opt assembles, SPEC 7.7/10.2 + AGENTS + README + docs/calc.md + docs/divmod.md numbers updated. New driver drv/digits_layout.r8asm keeps the measurement honest (one clb_digits call, no output, value fed as 0=2047). |
||
|
|
01aa13d0f0 |
tape_run --profile: the walking share is measured, not estimated
A tape run now reports, on stderr (stdout keeps the out line):
profile: 314779 steps, 250112 of them pointer moves (79.5%)
> 125073 39.7% < 125039 39.7% + 22178 7.0% - 12395 3.9%
[ 25121 8.0% ] 4954 1.6% . 7 , 10
hottest cells (steps spent there): 11:30471 10:26446 9:25733 12:24879 ...
The flagship tape: 236441 steps, 180665 pointer moves (76.4%), hottest cells
91, 90, 92, 89, 87, 93, 88, 86, 85 -- which is exactly clb_digits' scratch block.
So the "walking is about seventy percent" line in AGENTS turns out to be right, and
now it is measured: this machine has no random access, every access costs
|delta address|, so layout is the performance knob -- which is also why the
peephole pass (that only cancels round trips) buys 17% of the steps.
TODO drops the --profile item; AGENTS gets the number and the conclusion, with the
two commands next to the other baseline entries.
|
||
|
|
a56a12f132 |
r8forge --opt: the peephole pass is part of the assembler now
The pass moved out of tests/tape_opt.cc into src/tape_opt.cc with a header (rot8_optimize(tape, cell_size)), so both entry points share one implementation: r8forge --opt file.r8asm > t.rot8 assemble, then optimise in memory r8forge_tape_opt t.rot8 t2.rot8 optimise a tape assembled earlier --opt is peeled off argv before the rest of the parsing, so it can appear anywhere and the existing flags are untouched; without it the output is byte for byte what it was (flagship 64513). Measured: flagship 64513 -> 58060 (-10.0%), calculator 62585 -> 54863 (-12.3%), and "12 34 + ." still prints the same out stream from the optimised calculator. ctest 8/8 still green. |
||
|
|
ca72e19b0b |
tape_opt: the peephole pass -- 10% off the flagship tape with identical output
r8forge_tape_opt rewrites a tape with three run-local rules: > < a maximal run of pointer moves becomes its net displacement + a run becomes (length % _CELL_SIZE), a whole turn is a no-op - a run becomes (length % 2), two flips cancel The nice part is what it does NOT do: it never looks at brackets. '[' and ']' are not in any of the three character classes, so they always end a run, and within a run only the net matters (the pointer moves are pure additions and nothing in between is observable). Keeping every run's net keeps the pointer identical at every surviving character, brackets included, so the pairing that the machine finds by scanning cannot change; and since bracket characters are never added or removed, a run can never be merged across one. No stack, no offset table, one linear pass. Measured, with tape_run's out stream compared before and after (and the reference machine on the flagship's -n stream, same 93 values): asm/test.r8asm 64513 -> 58060 (-6453, 10.0%) examples/calc.r8asm 62585 -> 54863 (-7722, 12.3%) "12 34 + ." identical examples/term.r8asm 3467 -> 3402 ( -65, 1.9%) "hi" identical Step counts unchanged (the removed instructions did nothing). Not yet wired into `r8forge` itself: the pipeline is `r8forge f.r8asm > t.rot8 && r8forge_tape_opt t.rot8 t2.rot8`, and a --opt flag can wrap that later. |
||
|
|
55ab5dfebd |
examples: the terminal tape -- prompt, echo, newline, backspace, EOF
examples/term.r8asm is the "type at it and it answers" program: it prints "> ", then
echoes every character the machine reads, prints a fresh prompt after each newline,
and answers a backspace with space + backspace so the cursor erases the glyph.
EOF (the 0 that inp returns when the input is gone) erases the loop quota, so the
loop ends and the tape runs off its end after one final newline.
tape 3467 characters, 4743 steps for a two line session (the calculator is 62585)
Measured (derive and tape_run, then the reference machine's serial output):
in hi out 62 32 104 105 10 "> hi\n"
in hi<LF>ok out 62 32 104 105 10 62 32 111 107 10 two prompts
in h<BS>i out 62 32 104 8 32 8 105 10 the 8 32 8 pair
All three character streams agree with ROT-8-viz byte for byte (bar CRLF).
r8forge_examples_test passes all 18 examples.
One thing worth recording: my brief for this said "a body entered on LSB==0 needs no
clear" -- that is backwards, `[` *jumps* on LSB==0, so bodies are entered on LSB==1.
Following it inverted the dispatch (EOF fired with C=0x68) and it took a
`tape_run --trace` to see it; the file now documents the real rule next to the loop.
|
||
|
|
67a2b16721 | docs: 53 macros, and they live in 23 files now (puts_dyn.r8asm is new) | ||
|
|
a1f88e3d25 |
asm: raw_puts_dyn -- print a buffer whose length is only known at run time
A terminal has to echo the line the user just typed, and that length is a cell, not a constant; clb_puts cannot do it because .tp takes a literal address. So this one walks MAX compile time slots and decides per slot whether to print: CNT starts as a copy of LEN, clb_nonzero turns "CNT != 0" into the flag F, and the print happens inside `biz F` with the countdown *inside* the guarded body as well. That last detail is the whole bug this round: with clb_dec_ip outside the guard, a CNT of 0 wrapped to 2047 on the first skipped cell and the rest of the buffer came out (LEN=0 printed E F G H). The fix is also why the driver covers LEN = 3, 0 and 8 -- the zero case is what caught it. drv/puts_dyn.r8asm 13376 chars, out 65 66 67 65 66 67 68 69 70 71 72 (ABC, nothing, ABCDEFGH) reference machine "ABCABCDEFGH" 6306 steps Also learnt: `copy` takes two arguments (%this is the source), and it wants a clean buffer -- the first version passed three and then reused a dirty T, which showed up as a countdown that started from the wrong value. Not in asm/test.r8asm: an 8 slot version costs thousands of characters and the flagship is about a thousand under the 65536 limit. SPEC 5.3 records the contract and that exception; the macro count is 53. |
||
|
|
37d1dca0c7 | docs: the macro count is 52 (48 + load + clb_puts + test.r8asm's local load twice over) | ||
|
|
f7ac81b06f |
asm: clb_puts and load -- printing a sentence, and the constant helper
clb_puts REG LEN prints LEN consecutive cells as characters (the low 7 bits, which
is what serial OUT sends). LEN has to be an assembly time constant: .tp takes a
literal address here, so "print until the cell is zero" is not expressible -- the
walk would leave the data pointer somewhere else. Each character costs two .tp
plus one out (three or four tape characters), uses no extra cell and leaves the
source cells alone.
load N V is the helper every driver was writing by hand (erase then .xor): .xor is
an exclusive or, so a second load without the erase would mix with the old value.
drv/puts.r8asm 198 chars, in-family check: out 72 73 33 72 (HI! plus the
untouched source cell)
examples/hello.r8asm 727 chars, out 72 69 76 76 79 44 32 82 56 33, and the
reference machine prints "HELLO, R8!"
Both are documented in SPEC 5.2; the macro count goes 48 -> 50 and the examples 16
-> 17. The flagship tape is untouched (64513) because asm/test.r8asm still has its
own local load -- same body, and lib's definition comes first, so nothing changed.
|
||
|
|
1200880d4d |
TODO: drop the finished items, add what the last rounds turned up
Done and removed: the desk calculator (examples/calc.r8asm -- 62585 characters at 11 bits, three implementations agree, width matrix in tests/widths.ps1), the INP whole-cell semantic fix, and the reference machine's support for tapes above 64k. In their place, under "interactive computing": the RPN stack (fixed depth, because .tp is an assembly time constant -- 16 deep is about 12k of tape, 200 deep would be 100k per push), the terminal tape (prompt, echo, line editing, one session per `; in` header), and clb_puts / printf so a program can print a sentence. New tail: ROT-8-viz still has zero tests, and its old fixed-buffer read_tape is now unused; INS_SIZE is a historical constant next to ROT8_MAX_TAPE (16M instructions). |
||
|
|
ba5a8a465d |
tests/widths.ps1: assert the calculator at every width, not just print it
The script used to build the toolchain per width, run the widthfree label and
print whatever the calculator produced. It now checks:
* widthfree ctest label passes;
* examples/calc.r8asm assembles, and `12 34 + .` prints exactly D digits where
D = floor(W * 30103 / 100000) + 1 -- the width's digit count, computed the same
way the library computes it. A build that silently ignored the width would
print four digits and fail here instead of looking green;
* if ROT-8-viz is built next door, it runs the same tape and prints the same
thing, which makes the three way check part of the matrix.
Also fixes the invocation: `-Widths` is a comma separated string now, because
`powershell -File ... -Widths 11,16` binds as one string and 11,16 became 1116.
Measured at cell 11 (the default): widthfree ok, tape 62585, calc ok
`out 62 32 48 48 52 54 10`, viz ok `> 0046`. Default list is 7,8,11,16,17,31,32;
each width is a full toolchain build, so the whole run is about twenty minutes.
|
||
|
|
a69260522b |
geometry: kDefaultCellSize now really reads R8FORGE_CELL_SIZE
The build option was plumbed all the way to the compiler (the generated vcxproj carries R8FORGE_CELL_SIZE=17) but geometry.hh still said = 11, so every width built an 11 bit toolchain -- which is why the first matrix run printed identical tapes for all nine widths. My earlier '16 and 32 verified' claims were therefore measurements of 11 bit binaries: synth_test and full_add are bit level blocks whose tape does not depend on the width, so they never noticed. Now at -DR8FORGE_CELL_SIZE=17: asm/test.r8asm 108789 characters (64513 at 11), examples/calc.r8asm 112795 (62585), and one session prints '> 000046' -- D is 6 at 17 bits, which is exactly floor(17*log10 2)+1. tests/widths.ps1 now prints the flagship and calculator tape lengths, because that is the evidence that a width took effect; an unchanged 64513 means it did not. |
||
|
|
e137b09958 |
tests/widths.ps1: do not pipe native stderr into the output stream
The first run died at cell 1: with ErrorActionPreference=Stop a native command whose stderr is captured through the pipeline becomes a terminating ErrorRecord, so r8asm's harmless 'cached, 5 blocks' line killed the script. Native calls now report through LASTEXITCODE and their stderr goes to \; the configure no longer passes CMAKE_BUILD_TYPE, which the Visual Studio generator ignores anyway (it printed a warning per width). |
||
|
|
b7de3cad23 |
calc: the digit window follows _CELL_SIZE
The desk calculator hardcoded a four cell window, which is only right at 11 bits: clb_digits and clb_undigits use D = _CELL_SIZE * 30103 / 100000 + 1 digits (3 at 8 bits, 5 at 16, 10 at 32). D is now a .var, the window is REG..REG+D-1, every cell after it moves by D-4 (zero at 11 bits, so the numeric map is unchanged), and the startup fill, the shift chain, the flush reset and the D outputs are all %for generated. Two more width hardcodes turned up outside the window and are fixed: the C restore after the four-ror bit 4 test was `%rep 7` (only 4+7=11 at the default), it is `%rep _CELL_SIZE - 4` now -- which emits the same seven rors at 11 bits, so the tape is byte for byte identical (62585 characters, every step count unchanged). The literal descending shift was tried first and assembles fine but is wrong: writing REG+D-2 before reading it clobbers the digit that is about to move, giving "> 0350" for 12 34 + . instead of "> 0046". The chain goes ascending, which is the exact generalisation of the old four copy chain. tests/widths.ps1 builds the toolchain at 1 2 7 8 11 16 17 31 32 bits, runs the widthfree label at each and, where the ASCII constants fit (>= 6), runs one calculator session. 1 and 2 cannot: '0' is 48 and a two bit cell holds 3. Verified at 11 bits: tape unchanged, all five sessions identical, derive agrees, r8forge_examples_test 16/16. |
||
|
|
b497bf0637 |
examples: the desk calculator -- 12 34 + . -> > 0046
The five stage drivers are now one program. examples/calc.r8asm is a two
register desk calculator: digits build a number, + - * / set the pending
operator, . prints the accumulator (`> 0046` + newline) and , clears it. EOF (the
0 that inp returns when the input runs out) erases the loop counter, so the loop
ends and the tape simply runs off its end.
in 12 34 + . out 62 32 48 48 52 54 10 (> 0046) 314777 steps
in 2047 3 / . out 62 32 48 54 56 50 10 (> 0682) 362281
in 7 6 * . out 62 32 48 48 52 50 10 (> 0042) 299352
in 9 4 - . out 62 32 48 48 48 53 10 (> 0005) 292030
both of the first two in one session 659759 steps
62585 characters, under ROT-8-viz's 65536 for the first time in this series, so
the whole calculator can be cross-checked against the reference machine later.
tape_run and derive agree, r8forge_examples_test passes all 16 examples, ctest 8/8.
Four deliberate departures from docs/calc.md, each forced by a measurement:
* settle before loading the new operand, and `.` settles too -- the literal
order printed 0034 for 12 34 + . because the space arrives before the + and
overwrites A; * the operator is one-hot (1 2 4 8) so settlement is four flat
mutually exclusive biz blocks; * the loop quota is refilled each round
(clb_ones can only make _CELL_SIZE ones, 11 here) instead of a fixed 128;
* three cell moves worth ~24k of tape: clb_undigits scratch 35..45 -> 5..15
(next to the window it decodes), result/display target 0 -> 20 (adjacent
scratch makes the %synth blocks shorter), 35..45 reused as one shot flags.
Also found a trap worth remembering: a biz body that ended with `.tp B1; set_0`
(condition cell is FLAG) has net displacement +2, and only on the skipped path
does it desynchronise every later .tp -- the symptom was `-` and `,` sending the
tape into the weeds. Net displacement 0 on both paths, always.
|
||
|
|
f9821f8989 |
calc: stage 4 verified -- four operations, one shared scratch block
drv/calc_op.r8asm computes one case per operation and displays it with the stage 3
prompt, so the arithmetic path of the calculator is proven:
+ 12 34 -> 46 * 12 34 -> 408
- 100 30 -> 70 / 2047 3 -> 682
out 62 32 48 48 52 54 10 | 62 32 48 48 55 48 10
62 32 48 52 48 56 10 | 62 32 48 54 56 50 10
tape 77356 characters, 599090 steps, tape_run and derive agree on all 28 values.
The useful result is the memory map: the four macros want different scratch, and
one 7 cell block (23..29) serves all of them -- add/sub use its first cell as the
carry, clb_mul uses exactly those 7 as Ci PH MCA S T F NR, clb_divmod uses the same
7 as its S. They never run at the same time, so one erase before each call does
for all three. The result cell is the display's N cell directly (add/sub write S
there, mul writes PL, divmod writes Q), which saves a copy per case.
Contract probes confirm SPEC: add leaves the carry output 0, sub reports no-borrow
1, mul keeps MC and eats MUL, divmod keeps N and D and puts the remainder in R.
Over ROT-8-viz's 65536 limit (four expanded clb_digits blocks), so it is verified
through the two r8forge machines only; stage 5 loops the display, so the real
calculator will be smaller than this.
|
||
|
|
b2ba20b885 |
vms: raise the step cap from 5M to 20M
5 million steps was picked when the worst macro (clb_add_ip with B=2047) sat just under a million, so it caught hangs quickly. The interactive programs changed the arithmetic: one printed line of the desk calculator costs about 225k steps (40k for clb_undigits, up to 32k for the operation, ~141k for clb_digits), which is only about twenty lines before the cap, and examples_test applies the same cap to every example. At roughly 2.3e8 steps per second a 20M cap costs 0.09 s when a program really does run away, and byte_op_test (the only place that runs 465k programs) is unchanged -- so the safety net stays cheap while a session gets four times the room. docs/calc.md, docs/divmod.md, docs/byte-ops.md and SPEC's "500 ?" mentions now say 2000 ?. |
||
|
|
b83f3b1b06 |
calc_disp: correct the header's tape and step count
The numbers written into the header came from an earlier revision of the file (it
had the display body in there twice as long). Measured on what is committed:
tape 29188 characters, 282288 steps for the two prints
which is also what makes it fit under ROT-8-viz's 65536 instruction limit. The
out line was correct either way, which is why the mistake survived until the tape
was measured against the committed file.
|
||
|
|
bb1a434586 |
calc: stage 3 verified -- prompt, four digits, newline
drv/calc_disp.r8asm prints `> ` plus a number in decimal, twice (46 and 2047), so
the display path of the calculator is proven end to end:
out 62 32 48 48 52 54 10 62 32 50 48 52 55 10
> sp 0 0 4 6 LF > sp 2 0 4 7 LF
tape 58382 characters, 564578 steps (two clb_digits calls dominate), tape_run and
derive agree. This one fits under ROT-8-viz's 65536, unlike the two %rep 16/6
drivers.
The probe also pinned down which scratch really is sensitive: with cell 0 or the
four REG cells preset the output does not change (load erases, and the digit
shift chain flushes REG), but cell S+10 (the round counter, only set_1, never
cleared) and S+11 (clb_add_ip scratch) do change the first print -- "0047" and
"0000" respectively. So "the caller must hand in clean scratch" is real, and the
two prints need the erase between them.
|
||
|
|
b873d71082 |
calc: stage 2 verified -- the digit window and clb_undigits
drv/calc_num.r8asm reads 6 characters, shifts digits into a four cell ASCII
window (D3 D2 D1 D0, most significant first) and converts it with clb_undigits
whenever a non digit arrives, then resets the window to "0000".
in 12 34 out 12 34 tape 88413, 78908 steps
in 0 7 out 0 7 0 0 (each EOF read is a terminator too)
in 2047 out 2047 0
in 9999 out 1807 0 (9999 wraps mod 2048, as the machine does)
in 1234/0007 out 1234 0 / 7 0 (leading zeros work)
tape_run and derive agree on every case.
One deliberate departure from docs/calc.md: the digit branch copies the character
itself into the window instead of C - 48. clb_undigits xors each cell with 48 on
the way in, so the window has to hold ASCII -- storing the numeric value paid the
xor twice (first version: "12 34" -> 540 562, e.g. 49^48=1 but 1^48=49 then * 10 +
... lands at 540). So cell 2 (the 48 constant) and the sub_nc call are unused;
the file says so.
The window shift goes high to low (D3 <- D2 <- D1 <- D0) which is the order that
does not clobber unshifted digits; each copy is preceded by an erase of the
buffer even though this build's copy turns out to clean it itself.
|
||
|
|
cc75ed7ea4 |
drop the CI pipeline, keep the local ctest
The act_runner image has no cmake and installing it per run did not get through this network (even from a domestic mirror), so the pipeline was cost without a green run. Remove .gitea/workflows/ci.yml and the image recipe, keep what was useful on its own: * ctest --test-dir build -j 4 runs the 8 checks in about 9 s * README / AGENTS now point at that instead of six commands typed by hand TODO keeps a note: CI is paused, and ROT-8-viz is still the untested half. |
||
|
|
a48adc85c6 |
ci: install the toolchain again, from a domestic mirror
ci / cell 16 (push) Skipped
ci / cell 32 (push) Skipped
ci / cell 8 (push) Skipped
ci / wide sweep (manual) (11) (push) Skipped
ci / wide sweep (manual) (16) (push) Skipped
ci / wide sweep (manual) (24) (push) Skipped
ci / wide sweep (manual) (32) (push) Skipped
ci / wide sweep (manual) (8) (push) Skipped
ci / cold cache (manual) (push) Skipped
ci / baseline (11 bit) (push) Failing after 1m41s
Back to apt-get per run, but archive.ubuntu.com is the slowest hop here: the step rewrites sources.list (jammy and older) or the deb822 .sources (noble and newer) to TUNA before updating, then installs cmake/g++/make. APT_MIRROR is a knob -- aliyun and ustc are one edit away. ci/Dockerfile stays as the option for a runner that would rather bake the toolchain in. |
||
|
|
5bc26f7762 |
ci: the image carries the toolchain, not the job
ci / cell 16 (push) Skipped
ci / cell 32 (push) Skipped
ci / cell 8 (push) Skipped
ci / wide sweep (manual) (11) (push) Skipped
ci / wide sweep (manual) (16) (push) Skipped
ci / wide sweep (manual) (24) (push) Skipped
ci / wide sweep (manual) (32) (push) Skipped
ci / wide sweep (manual) (8) (push) Skipped
ci / cold cache (manual) (push) Skipped
ci / baseline (11 bit) (push) Failing after 16s
An apt-get per run is slow, depends on the Ubuntu mirrors (the flakiest hop on this network) and makes a run non-reproducible. ci/Dockerfile builds the image once -- cmake, g++, make, git -- and the runner label points at it (ubuntu-latest:docker://r8forge-ci:24.04). The workflow now only proves the toolchain is there and explains how to fix a bare image, instead of installing it. |
||
|
|
9b1a8fc0de |
ci: install cmake and g++ before configuring
ci / cell 16 (push) Skipped
ci / cell 32 (push) Skipped
ci / cell 8 (push) Skipped
ci / wide sweep (manual) (11) (push) Skipped
ci / wide sweep (manual) (16) (push) Skipped
ci / wide sweep (manual) (24) (push) Skipped
ci / wide sweep (manual) (32) (push) Skipped
ci / wide sweep (manual) (8) (push) Skipped
ci / cold cache (manual) (push) Skipped
ci / baseline (11 bit) (push) Canceled after 1m25s
The runner image is a bare ubuntu with git and node but no cmake, so the very first step died with 'cmake: command not found' (exit 127). Every job now installs cmake/g++/make first and prints their versions plus the core count, which is also the environment snapshot the logs were missing. |
||
|
|
fa12494e43 |
calc: stage 1 verified -- the character dispatch of the desk calculator
ci / cell 16 (push) Skipped
ci / cell 32 (push) Skipped
ci / cell 8 (push) Skipped
ci / wide sweep (manual) (11) (push) Skipped
ci / wide sweep (manual) (16) (push) Skipped
ci / wide sweep (manual) (24) (push) Skipped
ci / wide sweep (manual) (32) (push) Skipped
ci / wide sweep (manual) (8) (push) Skipped
ci / cold cache (manual) (push) Skipped
ci / baseline (11 bit) (push) Failing after 16s
drv/calc_lex.r8asm reads 16 characters and classifies each one: digits print
1+value, the six commands (* + , - . / = 0x2A..0x2F) print 100+index, anything
else prints 200. The discriminator is bit 4 of the character (digits 0x30..0x39
have it, the command block does not), so four `ror`s and one `biz` split them,
and `t = C - 0x2A` is the command index.
Measured (tape_run and derive agree; tape 90738 chars, 29990 steps):
in 0 5 9 + - . , * (15 chars; the 16th inp is EOF -> 0)
out 1 200 6 200 10 200 101 200 103 200 104 200 102 200 100 200
i.e. 0->1, space->200, 5->6, 9->10, +->101, -->103, .->104, ,->102, *->100,
EOF->200. Full-alphabet cross-checks: "0123456789*+,-./" gives
1..10 then 100..105, sixteen letters give sixteen 200s, a one char input gives
its value and fifteen 200s.
Two things recorded in the file's header: 90738 characters is over ROT-8-viz's
65536 INS_SIZE because %rep 16 unrolls the body (this driver is verified through
derive/tape_run only; the final program will use a runtime loop instead), and the
bit 4 filter also sends 0x10..0x1F and 0x3A..0x3F down the digit path, which no
protocol input can reach.
This is also the file that slipped into the CI commit earlier -- now it has a
commit of its own with its measured numbers.
|