| """Tests for instruction encoding and compute-in-memory decoding.""" |
|
|
| import os |
| import sys |
| import unittest |
|
|
| sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__)))) |
|
|
| from hdc.isa import ( |
| OPCODES, |
| DecodeContext, |
| DecodeError, |
| decode_instr, |
| encode_instr, |
| format_operands, |
| opcode_table_text, |
| ) |
|
|
| D = 2000 |
|
|
|
|
| def ctx(**kw): |
| base = dict(d=D) |
| base.update(kw) |
| return DecodeContext(**base) |
|
|
|
|
| class TestRoundTrip(unittest.TestCase): |
| """Every field kind must survive encode -> bundle -> unbind -> cleanup.""" |
|
|
| CASES = [ |
| ("NOP", dict(), dict()), |
| ("HALT", dict(), dict()), |
| ("LDI", dict(regs=[3], imm=7), dict(imms=[7])), |
| ("MOV", dict(regs=[1, 2]), dict()), |
| ("ADD", dict(regs=[2, 0, 1]), dict()), |
| ("PERMUTE", dict(regs=[4, 5], imm=3), dict(imms=[3])), |
| ("POPC", dict(regs=[6, 7]), dict()), |
| ("JMP", dict(tgt=9), dict(tgts=[9])), |
| ("JNZ", dict(tgt=12), dict(tgts=[12])), |
| ("STORE", dict(name="out", regs=[6]), dict(names=["out"])), |
| ("LOAD", dict(regs=[7], name="out"), dict(names=["out"])), |
| ("RECALL", dict(regs=[9, 10], imm=3), dict(imms=[3])), |
| ("PRINTS", dict(text="hi there"), dict(strs=["hi there"])), |
| ( |
| "TOOL", |
| dict(regs=[0, 1, 2], tool="hdc.similarity"), |
| dict(tools=["hdc.similarity"]), |
| ), |
| ] |
|
|
| def test_roundtrip_fields(self): |
| for op, kw, alphabets in self.CASES: |
| with self.subTest(op=op): |
| hv = encode_instr(op, d=D, **kw) |
| dec = decode_instr(hv, ctx(**alphabets)) |
| self.assertEqual(dec.op, op) |
| self.assertEqual(dec.regs, list(kw.get("regs", []))) |
| self.assertEqual(dec.imm, kw.get("imm")) |
| self.assertEqual(dec.tgt, kw.get("tgt")) |
| self.assertEqual(dec.name, kw.get("name")) |
| self.assertEqual(dec.text, kw.get("text")) |
| self.assertEqual(dec.tool, kw.get("tool")) |
| self.assertGreater(dec.confidence, 0.2, msg="op %s" % op) |
|
|
| def test_margins_are_recorded(self): |
| dec = decode_instr(encode_instr("ADD", regs=[2, 0, 1], d=D), ctx()) |
| self.assertIn("op", dec.margins) |
| self.assertIn("ra", dec.margins) |
| self.assertGreater(dec.margins["op"], 0.0) |
|
|
| def test_whole_opcode_table_encodes(self): |
| for name in OPCODES: |
| with self.subTest(op=name): |
| |
| dec = decode_instr(encode_instr(name, d=D), ctx()) |
| self.assertEqual(dec.op, name) |
|
|
| def test_format_operands(self): |
| dec = decode_instr(encode_instr("STORE", name="out", regs=[6], d=D), ctx(names=["out"])) |
| self.assertEqual(format_operands(dec), "out, R6") |
| dec = decode_instr(encode_instr("JMP", tgt=9, d=D), ctx(tgts=[9])) |
| self.assertEqual(format_operands(dec), "@9") |
|
|
|
|
| class TestDegradedContext(unittest.TestCase): |
| def test_missing_literal_alphabet_still_decodes_opcode(self): |
| hv = encode_instr("LDI", regs=[3], imm=7, d=D) |
| dec = decode_instr(hv, ctx()) |
| self.assertEqual(dec.op, "LDI") |
| self.assertEqual(dec.regs, [3]) |
| self.assertIsNone(dec.imm) |
|
|
| def test_default_context_has_no_alphabets(self): |
| self.assertEqual(DecodeContext().imms, ()) |
| self.assertEqual(DecodeContext().names, ()) |
| |
| |
| dec = decode_instr(encode_instr("HALT", d=D), DecodeContext(d=D)) |
| self.assertEqual(dec.op, "HALT") |
|
|
|
|
| class TestErrors(unittest.TestCase): |
| def test_unknown_opcode(self): |
| with self.assertRaises(DecodeError): |
| encode_instr("FROBNICATE", d=D) |
|
|
| def test_register_out_of_range(self): |
| with self.assertRaises(DecodeError): |
| encode_instr("MOV", regs=[16], d=D) |
|
|
| def test_too_many_registers(self): |
| with self.assertRaises(DecodeError): |
| encode_instr("ADD", regs=[0, 1, 2, 3], d=D) |
|
|
| def test_negative_register(self): |
| with self.assertRaises(DecodeError): |
| encode_instr("MOV", regs=[-1], d=D) |
|
|
|
|
| class TestTable(unittest.TestCase): |
| def test_table_text_mentions_every_opcode(self): |
| text = opcode_table_text() |
| for name in OPCODES: |
| self.assertIn(name, text) |
|
|
| def test_effects_are_known_classes(self): |
| allowed = {"ctrl", "alu", "hd", "mem", "io", "tool", "debug"} |
| for op in OPCODES.values(): |
| self.assertIn(op.effect, allowed) |
|
|
|
|
| if __name__ == "__main__": |
| unittest.main() |
|
|
