src/openpower/decoder/isa/test_caller_svp64_matrix.py

   1 from nmigen import Module, Signal
   2 from nmigen.back.pysim import Simulator, Delay, Settle
   3 from nmutil.formaltest import FHDLTestCase
   4 import unittest
   5 from openpower.decoder.isa.caller import ISACaller
   6 from openpower.decoder.power_decoder import (create_pdecode)
   7 from openpower.decoder.power_decoder2 import (PowerDecode2)
   8 from openpower.simulator.program import Program
   9 from openpower.decoder.isa.caller import ISACaller, SVP64State
  10 from openpower.decoder.selectable_int import SelectableInt
  11 from openpower.decoder.orderedset import OrderedSet
  12 from openpower.decoder.isa.all import ISA
  13 from openpower.decoder.isa.test_caller import Register, run_tst
  14 from openpower.sv.trans.svp64 import SVP64Asm
  15 from openpower.consts import SVP64CROffs
  16 from copy import deepcopy
  17 from openpower.decoder.helpers import fp64toselectable
  18 from openpower.decoder.isafunctions.double2single import DOUBLE2SINGLE
  19 from functools import reduce
  20 import operator
  21
  22
  23 class DecoderTestCase(FHDLTestCase):
  24
  25     def _check_regs(self, sim, expected):
  26         for i in range(32):
  27             self.assertEqual(sim.gpr(i), SelectableInt(expected[i], 64))
  28
  29     def test_sv_remap1(self):
  30         """>>> lst = ["svshape 2, 2, 3, 0, 0",
  31                         "svremap 31, 1, 2, 3, 0, 0, 0",
  32                        "sv.fmadds 0.v, 8.v, 16.v, 0.v"
  33                         ]
  34                 REMAP fmadds FRT, FRA, FRC, FRB
  35         """
  36         lst = SVP64Asm(["svshape 2, 2, 3, 0, 0",
  37                         "svremap 31, 1, 2, 3, 0, 0, 0",
  38                        "sv.fmadds 0.v, 16.v, 32.v, 0.v"
  39                         ])
  40         lst = list(lst)
  41
  42         fprs = [0] * 64
  43         # 3x2 matrix
  44         X1 = [[1, 2, 3],
  45               [3, 4, 5],
  46              ]
  47         # 2x3 matrix
  48         Y1 = [[6, 7],
  49               [8, 9],
  50               [10, 11],
  51              ]
  52
  53         X = X1
  54         Y = Y1
  55
  56         xf = reduce(operator.add, X)
  57         yf = reduce(operator.add, Y)
  58         print ("flattened X,Y")
  59         print ("\t", xf)
  60         print ("\t", yf)
  61
  62         # and create a linear result2, same scheme
  63         #result1 = [0] * (ydim1*xdim2)
  64
  65
  66         res = []
  67         # store FPs
  68         for i, x in enumerate(xf):
  69             fprs[i+16] = fp64toselectable(float(x))  # X matrix
  70         for i, y in enumerate(yf):
  71             fprs[i+32] = fp64toselectable(float(y)) # Y matrix
  72             continue
  73             #t = DOUBLE2SINGLE(fp64toselectable(t)) # convert to Power single
  74             #u = DOUBLE2SINGLE(fp64toselectable(u)) # from double
  75             #res.append((t, u))
  76             #print ("FFT", i, "in", a, b, "coeff", c, "mul",
  77             #       mul, "res", t, u)
  78
  79         with Program(lst, bigendian=False) as program:
  80             sim = self.run_tst_program(program, initial_fprs=fprs)
  81             print ("spr svshape0", sim.spr['SVSHAPE0'])
  82             print ("    xdimsz", sim.spr['SVSHAPE0'].xdimsz)
  83             print ("    ydimsz", sim.spr['SVSHAPE0'].ydimsz)
  84             print ("    zdimsz", sim.spr['SVSHAPE0'].zdimsz)
  85             print ("spr svshape1", sim.spr['SVSHAPE1'])
  86             print ("spr svshape2", sim.spr['SVSHAPE2'])
  87             print ("spr svshape3", sim.spr['SVSHAPE3'])
  88             for i in range(4):
  89                 print ("i", i, float(sim.fpr(i)))
  90             # confirm that the results are as expected
  91             #for i, (t, u) in enumerate(res):
  92             #    self.assertEqual(sim.fpr(i+2), t)
  93             #    self.assertEqual(sim.fpr(i+6), u)
  94
  95     def test_sv_remap2(self):
  96         """>>> lst = ["svshape 5, 4, 3, 0, 0",
  97                         "svremap 31, 1, 2, 3, 0, 0, 0, 0",
  98                        "sv.fmadds 0.v, 8.v, 16.v, 0.v"
  99                         ]
 100                 REMAP fmadds FRT, FRA, FRC, FRB
 101         """
 102         lst = SVP64Asm(["svshape 4, 3, 3, 0, 0",
 103                         "svremap 31, 1, 2, 3, 0, 0, 0, 0",
 104                        "sv.fmadds 0.v, 16.v, 32.v, 0.v"
 105                         ])
 106         lst = list(lst)
 107
 108         # 3x2 matrix
 109         X1 = [[1, 2, 3],
 110               [3, 4, 5],
 111              ]
 112         # 2x3 matrix
 113         Y1 = [[6, 7],
 114               [8, 9],
 115               [10, 11],
 116              ]
 117
 118         #### test matrices 2
 119         # 3x3 matrix
 120         X2 = [[12,7,3],
 121             [4 ,5,6],
 122             [7 ,8,9],
 123             ]
 124         # 3x4 matrix
 125         Y2 = [[5,8,1,2],
 126             [6,7,3,0],
 127             [4,5,9,1]]
 128
 129         #### test matrices 3
 130         # 3x4 matrix
 131         X3 = [[12,7,3],
 132             [4 ,5,6],
 133             [7 ,8,9],
 134             [2 ,0,1]]
 135         # 3x5 matrix
 136         Y3 = [[5,8,1,2,3],
 137             [6,7,3,0,9],
 138             [4,5,9,1,2]]
 139
 140         X = X2
 141         Y = Y2
 142
 143         # get the dimensions of the 2 matrices
 144         xdim1 = len(X[0])
 145         ydim1 = len(X)
 146         xdim2 = len(Y[0])
 147         ydim2 = len(Y)
 148
 149         print ("xdim2 ydim1 ydim2", xdim2, ydim1, ydim2)
 150
 151         xf = reduce(operator.add, X)
 152         yf = reduce(operator.add, Y)
 153         print ("flattened X,Y")
 154         print ("\t", xf)
 155         print ("\t", yf)
 156
 157         # and create a linear result2, same scheme
 158         #result1 = [0] * (ydim1*xdim2)
 159
 160
 161         res = []
 162         # store FPs
 163         fprs = [0] * 64
 164         for i, x in enumerate(xf):
 165             fprs[i+16] = fp64toselectable(float(x))  # X matrix
 166         for i, y in enumerate(yf):
 167             fprs[i+32] = fp64toselectable(float(y)) # Y matrix
 168             continue
 169             #t = DOUBLE2SINGLE(fp64toselectable(t)) # convert to Power single
 170             #u = DOUBLE2SINGLE(fp64toselectable(u)) # from double
 171             #res.append((t, u))
 172             #print ("FFT", i, "in", a, b, "coeff", c, "mul",
 173             #       mul, "res", t, u)
 174
 175         with Program(lst, bigendian=False) as program:
 176             sim = self.run_tst_program(program, initial_fprs=fprs)
 177             print ("spr svshape0", sim.spr['SVSHAPE0'])
 178             print ("    xdimsz", sim.spr['SVSHAPE0'].xdimsz)
 179             print ("    ydimsz", sim.spr['SVSHAPE0'].ydimsz)
 180             print ("    zdimsz", sim.spr['SVSHAPE0'].zdimsz)
 181             print ("spr svshape1", sim.spr['SVSHAPE1'])
 182             print ("spr svshape2", sim.spr['SVSHAPE2'])
 183             print ("spr svshape3", sim.spr['SVSHAPE3'])
 184             for i in range(16):
 185                 print ("i", i, float(sim.fpr(i)))
 186             # confirm that the results are as expected
 187             #for i, (t, u) in enumerate(res):
 188             #    self.assertEqual(sim.fpr(i+2), t)
 189             #    self.assertEqual(sim.fpr(i+6), u)
 190
 191     def run_tst_program(self, prog, initial_regs=None,
 192                               svstate=None,
 193                               initial_mem=None,
 194                               initial_fprs=None):
 195         if initial_regs is None:
 196             initial_regs = [0] * 32
 197         simulator = run_tst(prog, initial_regs, mem=initial_mem,
 198                                                 initial_fprs=initial_fprs,
 199                                                 svstate=svstate)
 200
 201         print ("GPRs")
 202         simulator.gpr.dump()
 203         print ("FPRs")
 204         simulator.fpr.dump()
 205
 206         return simulator
 207
 208
 209 if __name__ == "__main__":
 210     unittest.main()