Prahaladha's picture
sync learned_computer: 75 files from /dev/shm/neucpu
30bd7c0 verified
Raw History Blame Contribute Delete
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