src/soc/fu/mul/test/test_pipe_caller_long.py

   1 import unittest
   2 from soc.fu.mul.test.helper import MulTestHelper
   3 from openpower.simulator.program import Program
   4 from soc.config.endian import bigendian
   5 from openpower.test.common import (TestAccumulatorBase)
   6 import random
   7
   8
   9 class MulTestCases2Arg(TestAccumulatorBase):
  10     def case_all(self):
  11         instrs = ["mulhw",
  12                   "mulhw.", "mullw",
  13                   "mullw.", "mullwo",
  14                   "mullwo.", "mulhwu",
  15                   "mulhwu.", "mulld",
  16                   "mulld.", "mulldo",
  17                   "mulldo.", "mulhd",
  18                   "mulhd.", "mulhdu",
  19                   "mulhdu."]
  20
  21         test_values = [
  22             0x0,
  23             0x1,
  24             0x2,
  25             0xFFFF_FFFF_FFFF_FFFF,
  26             0xFFFF_FFFF_FFFF_FFFE,
  27             0x7FFF_FFFF_FFFF_FFFF,
  28             0x8000_0000_0000_0000,
  29             0x1234_5678_0000_0000,
  30             0x1234_5678_8000_0000,
  31             0x1234_5678_FFFF_FFFF,
  32             0x1234_5678_7FFF_FFFF,
  33             0xffffffff,
  34             0x7fffffff,
  35             0x80000000,
  36             0xfffffffe,
  37             0xfffffffd
  38         ]
  39
  40         for instr in instrs:
  41             l = [f"{instr} 3, 1, 2"]
  42             # use "with" so as to close the files used
  43             with Program(l, bigendian) as prog:
  44                 for ra in test_values:
  45                     for rb in test_values:
  46                         initial_regs = [0] * 32
  47                         initial_regs[1] = ra
  48                         initial_regs[2] = rb
  49                         self.add_case(prog, initial_regs)
  50
  51     def case_all_rb_randint(self):
  52         instrs = ["mulhw",
  53                   "mulhw.", "mullw",
  54                   "mullw.", "mullwo",
  55                   "mullwo.", "mulhwu",
  56                   "mulhwu.", "mulld",
  57                   "mulld.", "mulldo",
  58                   "mulldo.", "mulhd",
  59                   "mulhd.", "mulhdu",
  60                   "mulhdu."]
  61
  62         test_values = [
  63             0x0,
  64             0x1,
  65             0x2,
  66             0xFFFF_FFFF_FFFF_FFFF,
  67             0xFFFF_FFFF_FFFF_FFFE,
  68             0x7FFF_FFFF_FFFF_FFFF,
  69             0x8000_0000_0000_0000,
  70             0x1234_5678_0000_0000,
  71             0x1234_5678_8000_0000,
  72             0x1234_5678_FFFF_FFFF,
  73             0x1234_5678_7FFF_FFFF,
  74             0xffffffff,
  75             0x7fffffff,
  76             0x80000000,
  77             0xfffffffe,
  78             0xfffffffd
  79         ]
  80
  81         for instr in instrs:
  82             l = [f"{instr} 3, 1, 2"]
  83             # use "with" so as to close the files used
  84             with Program(l, bigendian) as prog:
  85                 for ra in test_values:
  86                     initial_regs = [0] * 32
  87                     initial_regs[1] = ra
  88                     initial_regs[2] = random.randint(0, (1 << 64)-1)
  89                     self.add_case(prog, initial_regs)
  90
  91     def case_all_rb_close_to_ov(self):
  92         instrs = ["mulhw",
  93                   "mulhw.", "mullw",
  94                   "mullw.", "mullwo",
  95                   "mullwo.", "mulhwu",
  96                   "mulhwu.", "mulld",
  97                   "mulld.", "mulldo",
  98                   "mulldo.", "mulhd",
  99                   "mulhd.", "mulhdu",
 100                   "mulhdu."]
 101
 102         test_values = [
 103             0x0,
 104             0x1,
 105             0x2,
 106             0xFFFF_FFFF_FFFF_FFFF,
 107             0xFFFF_FFFF_FFFF_FFFE,
 108             0x7FFF_FFFF_FFFF_FFFF,
 109             0x8000_0000_0000_0000,
 110             0x1234_5678_0000_0000,
 111             0x1234_5678_8000_0000,
 112             0x1234_5678_FFFF_FFFF,
 113             0x1234_5678_7FFF_FFFF,
 114             0xffffffff,
 115             0x7fffffff,
 116             0x80000000,
 117             0xfffffffe,
 118             0xfffffffd
 119         ]
 120
 121         for instr in instrs:
 122             l = [f"{instr} 3, 1, 2"]
 123             # use "with" so as to close the files used
 124             with Program(l, bigendian) as prog:
 125                 for i in range(20):
 126                     x = 0x7fffffff + random.randint((-1 << 31), (1 << 31) - 1)
 127                     ra = random.randint(0, (1 << 32)-1)
 128                     rb = x // ra
 129
 130                     initial_regs = [0] * 32
 131                     initial_regs[1] = ra
 132                     initial_regs[2] = rb
 133                     self.add_case(prog, initial_regs)
 134
 135     def case_mulli(self):
 136
 137         imm_values = [-32768, -32767, -32766, -2, -1, 0, 1, 2, 32766, 32767]
 138
 139         ra_values = [
 140             0x0,
 141             0x1,
 142             0x2,
 143             0xFFFF_FFFF_FFFF_FFFF,
 144             0xFFFF_FFFF_FFFF_FFFE,
 145             0x7FFF_FFFF_FFFF_FFFF,
 146             0x8000_0000_0000_0000,
 147             0x1234_5678_0000_0000,
 148             0x1234_5678_8000_0000,
 149             0x1234_5678_FFFF_FFFF,
 150             0x1234_5678_7FFF_FFFF,
 151             0xffffffff,
 152             0x7fffffff,
 153             0x80000000,
 154             0xfffffffe,
 155             0xfffffffd
 156         ]
 157
 158         for i in range(20):
 159             imm_values.append(random.randint(-1 << 15, (1 << 15) - 1))
 160
 161         for i in range(14):
 162             ra_values.append(random.randint(0, (1 << 64) - 1))
 163
 164         for imm in imm_values:
 165             l = [f"mulli 0, 1, {imm}"]
 166             # use "with" so as to close the files used
 167             with Program(l, bigendian) as prog:
 168                 for ra in ra_values:
 169                     initial_regs = [0] * 32
 170                     initial_regs[1] = ra
 171                     self.add_case(prog, initial_regs)
 172
 173
 174 MUL_3_ARG_TEST_VALUES = [
 175     0x0,
 176     0x1,
 177     0x2,
 178     0xFFFF_FFFF_FFFF_FFFF,
 179     0xFFFF_FFFF_FFFF_FFFE,
 180     0x7FFF_FFFF_FFFF_FFFF,
 181     0x8000_0000_0000_0000,
 182     0x1234_5678_0000_0000,
 183     0x1234_5678_8000_0000,
 184     0x1234_5678_FFFF_FFFF,
 185     0x1234_5678_7FFF_FFFF,
 186     0xffffffff,
 187     0x7fffffff,
 188     0x80000000,
 189     0xfffffffe,
 190     0xfffffffd
 191 ]
 192
 193
 194 class MulTestCases3Arg(TestAccumulatorBase):
 195     def __init__(self, subtest_index):
 196         self.subtest_index = subtest_index
 197         super().__init__()
 198
 199     def case_all(self):
 200         instrs = ["maddhd", "maddhdu", "maddld"]
 201
 202         for instr in instrs:
 203             l = [f"{instr} 1, 2, 3, 4"]
 204             ra = MUL_3_ARG_TEST_VALUES[self.subtest_index]
 205             for rb in MUL_3_ARG_TEST_VALUES:
 206                 for rc in MUL_3_ARG_TEST_VALUES:
 207                     initial_regs = [0] * 32
 208                     initial_regs[2] = ra
 209                     initial_regs[3] = rb
 210                     initial_regs[4] = rc
 211                     # use "with" so as to close the files used
 212                     with Program(l, bigendian) as prog:
 213                         self.add_case(prog, initial_regs)
 214
 215
 216 class TestPipeLong(MulTestHelper):
 217     def test_mul_pipe_2_arg(self):
 218         self.run_all(MulTestCases2Arg().test_data, "mul_pipe_caller_long_2_arg",
 219                      has_third_input=False)
 220
 221     def helper_3_arg(self, subtest_index):
 222         self.run_all(MulTestCases3Arg(subtest_index).test_data,
 223                      f"mul_pipe_caller_long_3_arg_{subtest_index}",
 224                      has_third_input=True)
 225
 226     # split out as separate functions so some test
 227     # runners can test them all in parallel
 228     def test_mul_pipe_3_arg_0(self):
 229         self.helper_3_arg(0)
 230
 231     def test_mul_pipe_3_arg_1(self):
 232         self.helper_3_arg(1)
 233
 234     def test_mul_pipe_3_arg_2(self):
 235         self.helper_3_arg(2)
 236
 237     def test_mul_pipe_3_arg_3(self):
 238         self.helper_3_arg(3)
 239
 240     def test_mul_pipe_3_arg_4(self):
 241         self.helper_3_arg(4)
 242
 243     def test_mul_pipe_3_arg_5(self):
 244         self.helper_3_arg(5)
 245
 246     def test_mul_pipe_3_arg_6(self):
 247         self.helper_3_arg(6)
 248
 249     def test_mul_pipe_3_arg_7(self):
 250         self.helper_3_arg(7)
 251
 252     def test_mul_pipe_3_arg_8(self):
 253         self.helper_3_arg(8)
 254
 255     def test_mul_pipe_3_arg_9(self):
 256         self.helper_3_arg(9)
 257
 258     def test_mul_pipe_3_arg_10(self):
 259         self.helper_3_arg(10)
 260
 261     def test_mul_pipe_3_arg_11(self):
 262         self.helper_3_arg(11)
 263
 264     def test_mul_pipe_3_arg_12(self):
 265         self.helper_3_arg(12)
 266
 267     def test_mul_pipe_3_arg_13(self):
 268         self.helper_3_arg(13)
 269
 270     def test_mul_pipe_3_arg_14(self):
 271         self.helper_3_arg(14)
 272
 273     def test_mul_pipe_3_arg_15(self):
 274         self.helper_3_arg(15)
 275
 276     def test_all_values_covered(self):
 277         count = len(MUL_3_ARG_TEST_VALUES)
 278         for i in range(count):
 279             getattr(self, f"test_mul_pipe_3_arg_{i}")
 280         with self.assertRaises(AttributeError):
 281             getattr(self, f"test_mul_pipe_3_arg_{count}")
 282
 283
 284 if __name__ == "__main__":
 285     unittest.main()