Download neucpu/tiny8.py from Prahaladha/learned-computer: direct link, hf CLI and curl.
- Browser
- Download file 6.83 kB
-
https://huggingface.co/Prahaladha/learned-computer/resolve/main/neucpu/tiny8.py
- Command line
-
hf download hf://Prahaladha/learned-computer/neucpu/tiny8.py
-
curl -L -o tiny8.py https://huggingface.co/Prahaladha/learned-computer/resolve/main/neucpu/tiny8.py
6.83 kB
| """Tiny8: the small 8-bit computer the network learns to BE. | |
| State = 477 bytes, every one a token for the network: | |
| [0..7] registers R0..R7 | |
| [8] PC (byte address into ROM; instructions are 2 bytes) | |
| [9] SP (stack pointer; the stack lives at the top of RAM, first push lands at 127) | |
| [10] flags: bit0 Z (result was zero), bit1 C (carry / borrow / error) | |
| [11] output pointer [12] input pointer | |
| [13..76] output tape, 64 cells (OUT writes here) | |
| [77..204] RAM, 128 bytes | |
| ---- everything above changes; everything below is read-only input ---- | |
| [205..460] ROM, 256 bytes (the program) | |
| [461..476] input tape, 16 bytes (IN reads here) | |
| One step() = one instruction. Instruction = 2 bytes: (opcode << 3 | register r), argument byte. | |
| """ | |
| import numpy as np | |
| O_R, O_PC, O_SP, O_FL, O_OP, O_IP = 0, 8, 9, 10, 11, 12 | |
| O_OUT, N_OUT = 13, 64 | |
| O_RAM, N_RAM = 77, 128 | |
| N_STATE = 205 | |
| O_ROM, N_ROM = 205, 256 | |
| O_IN, N_IN = 461, 16 | |
| N_TOK = 477 | |
| OPS = ["HALT", "LDI", "MOV", "ADD", "SUB", "ADDI", "SUBI", "MUL", "DIV", "MOD", "AND", "OR", "XOR", "SHL", "SHR", "CMP", | |
| "CMPI", "JMP", "JZ", "JNZ", "JC", "JNC", "CALL", "RET", "PUSH", "POP", "LD", "ST", "LDA", "STA", "OUT", "IN"] | |
| OP = {n: i for i, n in enumerate(OPS)} | |
| # argument kind per op: 'r' second register, 'i' immediate, 'a' ROM address, 'm' RAM address, '' none | |
| ARG = {"HALT": "", "LDI": "i", "MOV": "r", "ADD": "r", "SUB": "r", "ADDI": "i", "SUBI": "i", "MUL": "r", "DIV": "r", | |
| "MOD": "r", "AND": "r", "OR": "r", "XOR": "r", "SHL": "", "SHR": "", "CMP": "r", "CMPI": "i", "JMP": "a", | |
| "JZ": "a", "JNZ": "a", "JC": "a", "JNC": "a", "CALL": "a", "RET": "", "PUSH": "", "POP": "", "LD": "r", "ST": "r", | |
| "LDA": "m", "STA": "m", "OUT": "", "IN": ""} | |
| USES_R = {n for n in OPS if n not in ("HALT", "JMP", "JZ", "JNZ", "JC", "JNC", "CALL", "RET")} | |
| def boot(rom: bytes, inp=()): | |
| s = np.zeros(N_TOK, np.uint8) | |
| rom = bytes(rom)[:N_ROM] | |
| s[O_ROM:O_ROM + len(rom)] = np.frombuffer(rom, np.uint8) | |
| s[O_SP] = 128 | |
| inp = list(inp)[:N_IN] | |
| s[O_IN:O_IN + len(inp)] = inp | |
| return s | |
| def step(s: np.ndarray) -> np.ndarray: | |
| """Pure function: next state (ROM and input tape copied unchanged).""" | |
| n = s.copy() | |
| R = n[O_R:O_R + 8].astype(np.int64) | |
| ram = n[O_RAM:O_RAM + N_RAM] | |
| pc = int(n[O_PC]) | |
| b0, arg = int(n[O_ROM + pc]), int(n[O_ROM + ((pc + 1) & 255)]) | |
| op, r = b0 >> 3, b0 & 7 | |
| s2 = arg & 7 | |
| z, c = int(n[O_FL]) & 1, (int(n[O_FL]) >> 1) & 1 | |
| npc = (pc + 2) & 255 | |
| sp = int(n[O_SP]) | |
| name = OPS[op] | |
| def setzc(v, carry): | |
| nonlocal z, c | |
| z, c = int((v & 255) == 0), int(carry) | |
| if name == "HALT": | |
| npc = pc | |
| elif name == "LDI": | |
| R[r] = arg | |
| elif name == "MOV": | |
| R[r] = R[s2] | |
| elif name in ("ADD", "ADDI"): | |
| b = R[s2] if name == "ADD" else arg | |
| v = R[r] + b | |
| R[r] = v & 255 | |
| setzc(v, v > 255) | |
| elif name in ("SUB", "SUBI"): | |
| b = R[s2] if name == "SUB" else arg | |
| v = R[r] - b | |
| R[r] = v & 255 | |
| setzc(v, R[r] != v) # borrow | |
| elif name == "MUL": | |
| v = R[r] * R[s2] | |
| R[r] = v & 255 | |
| setzc(v, v > 255) | |
| elif name in ("DIV", "MOD"): | |
| b = R[s2] | |
| if b == 0: | |
| R[r] = 0 | |
| setzc(0, 1) | |
| else: | |
| R[r] = R[r] // b if name == "DIV" else R[r] % b | |
| setzc(R[r], 0) | |
| elif name in ("AND", "OR", "XOR"): | |
| R[r] = (R[r] & R[s2]) if name == "AND" else (R[r] | R[s2]) if name == "OR" else (R[r] ^ R[s2]) | |
| setzc(R[r], 0) | |
| elif name == "SHL": | |
| v = R[r] << 1 | |
| R[r] = v & 255 | |
| setzc(v, v > 255) | |
| elif name == "SHR": | |
| cbit = R[r] & 1 | |
| R[r] = R[r] >> 1 | |
| setzc(R[r], cbit) | |
| elif name in ("CMP", "CMPI"): | |
| b = R[s2] if name == "CMP" else arg | |
| setzc(R[r] - b, R[r] < b) | |
| elif name == "JMP": | |
| npc = arg & 254 | |
| elif name in ("JZ", "JNZ", "JC", "JNC"): | |
| cond = {"JZ": z == 1, "JNZ": z == 0, "JC": c == 1, "JNC": c == 0}[name] | |
| if cond: | |
| npc = arg & 254 | |
| elif name == "CALL": | |
| sp = (sp - 1) & 255 | |
| ram[sp & 127] = npc | |
| npc = arg & 254 | |
| elif name == "RET": | |
| npc = int(ram[sp & 127]) & 254 | |
| sp = (sp + 1) & 255 | |
| elif name == "PUSH": | |
| sp = (sp - 1) & 255 | |
| ram[sp & 127] = R[r] | |
| elif name == "POP": | |
| R[r] = ram[sp & 127] | |
| sp = (sp + 1) & 255 | |
| elif name == "LD": | |
| R[r] = ram[R[s2] & 127] | |
| elif name == "ST": | |
| ram[R[s2] & 127] = R[r] | |
| elif name == "LDA": | |
| R[r] = ram[arg & 127] | |
| elif name == "STA": | |
| ram[arg & 127] = R[r] | |
| elif name == "OUT": | |
| op_ = int(n[O_OP]) | |
| n[O_OUT + (op_ & 63)] = R[r] | |
| n[O_OP] = (op_ + 1) & 63 | |
| elif name == "IN": | |
| ip = int(n[O_IP]) | |
| R[r] = n[O_IN + (ip & 15)] | |
| n[O_IP] = (ip + 1) & 15 | |
| n[O_R:O_R + 8] = R.astype(np.uint8) | |
| n[O_PC] = npc | |
| n[O_SP] = sp | |
| n[O_FL] = z | (c << 1) | |
| return n | |
| def halted(s): | |
| pc = int(s[O_PC]) | |
| return (int(s[O_ROM + pc]) >> 3) == 0 | |
| def run(rom, inp=(), max_steps=100000): | |
| """Run to HALT; returns (final state, steps, printed numbers in order).""" | |
| s = boot(rom, inp) | |
| printed = [] | |
| for t in range(max_steps): | |
| if halted(s): | |
| return s, t, printed | |
| pc = int(s[O_PC]) | |
| if (int(s[O_ROM + pc]) >> 3) == OP["OUT"]: | |
| printed.append(int(s[O_R + (int(s[O_ROM + pc]) & 7)])) | |
| s = step(s) | |
| return s, max_steps, printed | |
| def assemble(lines): | |
| """Two-pass assembler. Lines: 'label:', 'OP r, arg' with registers r0..r7, numbers, labels, '.byte n' not supported (ROM is code only).""" | |
| labels, pc, ins = {}, 0, [] | |
| for ln in lines: | |
| ln = ln.split(";")[0].strip() | |
| if not ln: | |
| continue | |
| if ln.endswith(":"): | |
| labels[ln[:-1]] = pc | |
| continue | |
| ins.append(ln) | |
| pc += 2 | |
| if pc > N_ROM: | |
| raise ValueError(f"program too long: {pc} bytes > {N_ROM}") | |
| out = bytearray() | |
| for ln in ins: | |
| parts = ln.replace(",", " ").split() | |
| name = parts[0].upper() | |
| a = parts[1:] | |
| r = 0 | |
| if name in USES_R: | |
| r = int(a[0][1:]) | |
| a = a[1:] | |
| k = ARG[name] | |
| if k == "": | |
| v = 0 | |
| elif k == "r": | |
| v = int(a[0][1:]) | |
| else: | |
| t = a[0] | |
| v = labels[t] if t in labels else int(t, 0) | |
| out += bytes([(OP[name] << 3) | r, v & 255]) | |
| return bytes(out) | |
| def disasm(rom, pc): | |
| b0, arg = rom[pc], rom[(pc + 1) & 255] | |
| name, r = OPS[b0 >> 3], b0 & 7 | |
| k = ARG[name] | |
| s = name + (f" r{r}" if name in USES_R else "") | |
| if k == "r": | |
| s += f", r{arg & 7}" | |
| elif k: | |
| s += f", {arg}" | |
| return s | |