src/soc/fu/div/test/helper.py

   1 import random
   2 import unittest
   3 import power_instruction_analyzer as pia
   4 from nmigen import Module, Signal
   5 from nmigen.back.pysim import Simulator, Delay
   6 from soc.decoder.power_decoder import (create_pdecode)
   7 from soc.decoder.power_decoder2 import (PowerDecode2)
   8 from soc.decoder.power_enums import XER_bits, Function
   9 from soc.decoder.isa.all import ISA
  10 from soc.config.endian import bigendian
  11
  12 from soc.fu.test.common import ALUHelpers
  13 from soc.fu.div.pipeline import DivBasePipe
  14 from soc.fu.div.pipe_data import DivPipeSpec
  15
  16
  17 def log_rand(n, min_val=1):
  18     logrange = random.randint(1, n)
  19     return random.randint(min_val, (1 << logrange)-1)
  20
  21
  22 def get_cu_inputs(dec2, sim):
  23     """naming (res) must conform to DivFunctionUnit input regspec
  24     """
  25     res = {}
  26
  27     yield from ALUHelpers.get_sim_int_ra(res, sim, dec2)  # RA
  28     yield from ALUHelpers.get_sim_int_rb(res, sim, dec2)  # RB
  29     yield from ALUHelpers.get_sim_xer_so(res, sim, dec2)  # XER.so
  30
  31     print("alu get_cu_inputs", res)
  32
  33     return res
  34
  35
  36 def pia_res_to_output(pia_res):
  37     retval = {}
  38     if pia_res.rt is not None:
  39         retval["o"] = pia_res.rt
  40     if pia_res.cr0 is not None:
  41         cr0 = pia_res.cr0
  42         v = 0
  43         if cr0.lt:
  44             v |= 8
  45         if cr0.gt:
  46             v |= 4
  47         if cr0.eq:
  48             v |= 2
  49         if cr0.so:
  50             v |= 1
  51         retval["cr_a"] = v
  52     if pia_res.overflow is not None:
  53         overflow = pia_res.overflow
  54         v = 0
  55         if overflow.ov:
  56             v |= 1
  57         if overflow.ov32:
  58             v |= 2
  59         retval["xer_ov"] = v
  60         retval["xer_so"] = overflow.so
  61     else:
  62         retval["xer_ov"] = 0
  63         retval["xer_so"] = 0
  64     return retval
  65
  66
  67 def set_alu_inputs(alu, dec2, sim):
  68     # TODO: see https://bugs.libre-soc.org/show_bug.cgi?id=305#c43
  69     # detect the immediate here (with m.If(self.i.ctx.op.imm_data.imm_ok))
  70     # and place it into data_i.b
  71
  72     inp = yield from get_cu_inputs(dec2, sim)
  73     yield from ALUHelpers.set_int_ra(alu, dec2, inp)
  74     yield from ALUHelpers.set_int_rb(alu, dec2, inp)
  75
  76     yield from ALUHelpers.set_xer_so(alu, dec2, inp)
  77
  78     overflow = None
  79     if 'xer_so' in inp:
  80         so = inp['xer_so']
  81         overflow = pia.OverflowFlags(so=bool(so),
  82                                      ov=False,
  83                                      ov32=False)
  84     return pia.InstructionInput(ra=inp["ra"], rb=inp["rb"], overflow=overflow)
  85
  86
  87 class DivTestHelper(unittest.TestCase):
  88     def execute(self, alu, instruction, pdecode2, test, div_pipe_kind, sim):
  89         prog = test.program
  90         isa_sim = ISA(pdecode2, test.regs, test.sprs, test.cr,
  91                       test.mem, test.msr,
  92                       bigendian=bigendian)
  93         gen = prog.generate_instructions()
  94         instructions = list(zip(gen, prog.assembly.splitlines()))
  95         yield Delay(0.1e-6)
  96
  97         index = isa_sim.pc.CIA.value//4
  98         while index < len(instructions):
  99             ins, code = instructions[index]
 100
 101             print("instruction: 0x{:X}".format(ins & 0xffffffff))
 102             print(code)
 103             spr = isa_sim.spr
 104             if 'XER' in spr:
 105                 so = 1 if spr['XER'][XER_bits['SO']] else 0
 106                 ov = 1 if spr['XER'][XER_bits['OV']] else 0
 107                 ov32 = 1 if spr['XER'][XER_bits['OV32']] else 0
 108                 print("before: so/ov/32", so, ov, ov32)
 109
 110             # ask the decoder to decode this binary data (endian'd)
 111             # little / big?
 112             yield pdecode2.dec.bigendian.eq(bigendian)
 113             yield instruction.eq(ins)          # raw binary instr.
 114             yield Delay(0.1e-6)
 115             fn_unit = yield pdecode2.e.do.fn_unit
 116             self.assertEqual(fn_unit, Function.DIV.value)
 117             pia_inputs = yield from set_alu_inputs(alu, pdecode2,
 118                                                    isa_sim)
 119
 120             # set valid for one cycle, propagate through pipeline..
 121             # note that it is critically important to do this
 122             # for DIV otherwise it starts trying to produce
 123             # multiple results.
 124             yield alu.p.valid_i.eq(1)
 125             yield
 126             yield alu.p.valid_i.eq(0)
 127
 128             opname = code.split(' ')[0]
 129             fnname = opname.replace(".", "_")
 130             print(f"{fnname}({pia_inputs})")
 131             pia_res = getattr(
 132                 pia, opname.replace(".", "_"))(pia_inputs)
 133             print(f"-> {pia_res}")
 134
 135             yield from isa_sim.call(opname)
 136             index = isa_sim.pc.CIA.value//4
 137
 138             vld = yield alu.n.valid_o
 139             while not vld:
 140                 yield
 141                 yield Delay(0.1e-6)
 142                 # XXX sim._engine is an internal variable
 143                 # Waiting on https://github.com/nmigen/nmigen/issues/443
 144                 try:
 145                     print(f"time: {sim._engine.now * 1e6}us")
 146                 except AttributeError:
 147                     pass
 148                 vld = yield alu.n.valid_o
 149                 # bug #425 investigation
 150                 do = alu.pipe_end.div_out
 151                 ctx_op = do.i.ctx.op
 152                 is_32bit = yield ctx_op.is_32bit
 153                 is_signed = yield ctx_op.is_signed
 154                 quotient_root = yield do.i.core.quotient_root
 155                 quotient_65 = yield do.quotient_65
 156                 dive_abs_ov32 = yield do.i.dive_abs_ov32
 157                 div_by_zero = yield do.i.div_by_zero
 158                 quotient_neg = yield do.quotient_neg
 159                 print("32bit", hex(is_32bit))
 160                 print("signed", hex(is_signed))
 161                 print("quotient_root", hex(quotient_root))
 162                 print("quotient_65", hex(quotient_65))
 163                 print("div_by_zero", hex(div_by_zero))
 164                 print("dive_abs_ov32", hex(dive_abs_ov32))
 165                 print("quotient_neg", hex(quotient_neg))
 166                 print("vld", vld)
 167                 print("")
 168
 169             yield Delay(0.1e-6)
 170             # XXX sim._engine is an internal variable
 171             # Waiting on https://github.com/nmigen/nmigen/issues/443
 172             try:
 173                 print(f"check time: {sim._engine.now * 1e6}us")
 174             except AttributeError:
 175                 pass
 176             msg = "%s: %s" % (div_pipe_kind.name, code)
 177             msg += " %s" % (repr(prog.assembly))
 178             msg += " %s" % (repr(test.regs))
 179             yield from self.check_alu_outputs(alu, pdecode2,
 180                                               isa_sim, msg,
 181                                               pia_res)
 182             yield
 183
 184     def run_all(self, test_data, div_pipe_kind, file_name_prefix):
 185         m = Module()
 186         comb = m.d.comb
 187         instruction = Signal(32)
 188
 189         pdecode = create_pdecode()
 190
 191         m.submodules.pdecode2 = pdecode2 = PowerDecode2(pdecode)
 192
 193         pspec = DivPipeSpec(id_wid=2, div_pipe_kind=div_pipe_kind)
 194         m.submodules.alu = alu = DivBasePipe(pspec)
 195
 196         comb += alu.p.data_i.ctx.op.eq_from_execute1(pdecode2.e)
 197         comb += alu.n.ready_i.eq(1)
 198         comb += pdecode2.dec.raw_opcode_in.eq(instruction)
 199         sim = Simulator(m)
 200
 201         sim.add_clock(1e-6)
 202
 203         def process():
 204             for test in test_data:
 205                 print(test.name)
 206                 with self.subTest(test.name):
 207                     yield from self.execute(alu, instruction, pdecode2,
 208                                             test, div_pipe_kind, sim)
 209
 210         sim.add_sync_process(process)
 211         with sim.write_vcd(f"{file_name_prefix}_{div_pipe_kind.name}.vcd"):
 212             sim.run()
 213
 214     def check_alu_outputs(self, alu, dec2, sim, code, pia_res):
 215
 216         rc = yield dec2.e.do.rc.data
 217         cridx_ok = yield dec2.e.write_cr.ok
 218         cridx = yield dec2.e.write_cr.data
 219
 220         print("check extra output", repr(code), cridx_ok, cridx)
 221         if rc:
 222             self.assertEqual(cridx, 0, code)
 223
 224         sim_o = {}
 225         res = {}
 226
 227         yield from ALUHelpers.get_cr_a(res, alu, dec2)
 228         yield from ALUHelpers.get_xer_ov(res, alu, dec2)
 229         yield from ALUHelpers.get_int_o(res, alu, dec2)
 230         yield from ALUHelpers.get_xer_so(res, alu, dec2)
 231
 232         print("res output", res)
 233
 234         yield from ALUHelpers.get_sim_int_o(sim_o, sim, dec2)
 235         yield from ALUHelpers.get_wr_sim_cr_a(sim_o, sim, dec2)
 236         yield from ALUHelpers.get_sim_xer_ov(sim_o, sim, dec2)
 237         yield from ALUHelpers.get_sim_xer_so(sim_o, sim, dec2)
 238
 239         print("sim output", sim_o)
 240
 241         print("power-instruction-analyzer result:")
 242         print(pia_res)
 243         if pia_res is not None:
 244             with self.subTest(check="pia", sim_o=sim_o, pia_res=str(pia_res)):
 245                 pia_o = pia_res_to_output(pia_res)
 246                 ALUHelpers.check_int_o(self, res, pia_o, code)
 247                 ALUHelpers.check_cr_a(self, res, pia_o, code)
 248                 ALUHelpers.check_xer_ov(self, res, pia_o, code)
 249                 ALUHelpers.check_xer_so(self, res, pia_o, code)
 250
 251         with self.subTest(check="sim", sim_o=sim_o, pia_res=str(pia_res)):
 252             ALUHelpers.check_int_o(self, res, sim_o, code)
 253             ALUHelpers.check_cr_a(self, res, sim_o, code)
 254             ALUHelpers.check_xer_ov(self, res, sim_o, code)
 255             ALUHelpers.check_xer_so(self, res, sim_o, code)
 256
 257         oe = yield dec2.e.do.oe.oe
 258         oe_ok = yield dec2.e.do.oe.ok
 259         print("oe, oe_ok", oe, oe_ok)
 260         if not oe or not oe_ok:
 261             # if OE not enabled, XER SO and OV must not be activated
 262             so_ok = yield alu.n.data_o.xer_so.ok
 263             ov_ok = yield alu.n.data_o.xer_ov.ok
 264             print("so, ov", so_ok, ov_ok)
 265             self.assertEqual(ov_ok, False, code)
 266             self.assertEqual(so_ok, False, code)