src/openpower/decoder/isa/test_caller_transcendentals.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 copy import deepcopy
  15 from openpower.sv.trans.svp64 import SVP64Asm
  16 from openpower.decoder.helpers import fp64toselectable
  17 from openpower.decoder.isafunctions.double2single import DOUBLE2SINGLE
  18
  19 import math
  20
  21 class FPTranscendentalsTestCase(FHDLTestCase):
  22
  23     def _check_regs(self, sim, expected_int, expected_fpr):
  24         for i in range(32):
  25             self.assertEqual(sim.gpr(i), SelectableInt(expected[i], 64))
  26         for i in range(32):
  27             self.assertEqual(sim.fpr(i), SelectableInt(expected_fpr[i], 64))
  28
  29     def tst_fp_sins_coss(self):
  30         """>>> lst = ["fsins 1, 2",
  31                       "fcoss 3, 2",
  32                      ]
  33         """
  34         lst = SVP64Asm(["fsins 1, 2",
  35                         "fcoss 3, 2",
  36                      ])
  37         lst = list(lst)
  38
  39         with Program(lst, bigendian=False) as program:
  40             fprs = [0] * 32
  41             for i in range(-8, 9):
  42                 a = math.pi * (i / 8.0) * 2.0
  43                 fprs[2] = fp64toselectable(a)
  44                 t = math.sin(a)
  45                 u = math.cos(a)
  46                 a1 = fp64toselectable(a) # convert to Power single
  47                 t = DOUBLE2SINGLE(fp64toselectable(t)) # convert to Power single
  48                 u = DOUBLE2SINGLE(fp64toselectable(u)) # convert to Power single
  49
  50                 with self.subTest():
  51                     sim = self.run_tst_program(program, initial_fprs=fprs)
  52                     print("FPR 1", sim.fpr(1))
  53                     print("FPR 2", sim.fpr(2))
  54                     print("FPR 3", sim.fpr(3))
  55                     self.assertEqual(sim.fpr(2), SelectableInt(a1, 64))
  56                     self.assertEqual(sim.fpr(1), SelectableInt(t, 64))
  57                     self.assertEqual(sim.fpr(3), SelectableInt(u, 64))
  58
  59     def test_fp_coss_cvt(self):
  60         """>>> lst = [
  61                       "fcoss 3, 2",
  62                      ]
  63         """
  64         lst = SVP64Asm(["std 1, 0(0)",
  65                         "lfd 0, 0(0)",
  66                         "fcfids 0, 0",
  67                         "fadds 0, 0, 3", # plus 0.5
  68                         "fmuls 0, 0, 1", # times PI
  69                         "fdivs 0, 0, 2", # div 4.0
  70                         "fcoss 4, 0",
  71                      ])
  72         lst = list(lst)
  73
  74         with Program(lst, bigendian=False) as program:
  75             gprs = [0] * 32
  76             fprs = [0] * 32
  77             # constants
  78             fprs[3] = fp64toselectable(0.5)     # 0.5
  79             fprs[1] = fp64toselectable(math.pi) # pi
  80             fprs[2] = fp64toselectable(4.0)     # 4.0
  81             #for i in range(-8, 9):
  82             for i in range(7, 8):
  83                 a = math.pi * ((i+0.5) / 4.0)
  84                 gprs[1] = i
  85                 a1 = DOUBLE2SINGLE(fp64toselectable(a)) # to Power single
  86                 a = float(a1)
  87                 u = math.cos(a)
  88                 u = DOUBLE2SINGLE(fp64toselectable(u)) # convert to Power single
  89
  90                 with self.subTest():
  91                     sim = self.run_tst_program(program, gprs, initial_fprs=fprs)
  92                     print("FPR 0", sim.fpr(0), float(sim.fpr(0)))
  93                     print("FPR 1", sim.fpr(1), float(sim.fpr(1)))
  94                     print("FPR 2", sim.fpr(2), float(sim.fpr(2)))
  95                     print("FPR 3", sim.fpr(3), float(sim.fpr(3)))
  96                     print("FPR 4", sim.fpr(4), float(sim.fpr(4)))
  97                     # sign should not do this, but hey
  98                     actual_r = float(sim.fpr(0))
  99                     expected_r = float(a1)
 100                     err = abs(actual_r - expected_r ) / expected_r
 101                     self.assertTrue(err < 1e-6)
 102                     actual_r = float(sim.fpr(4))
 103                     expected_r = float(u)
 104                     err = abs(actual_r - expected_r ) / expected_r
 105                     self.assertTrue(err < 1e-6)
 106
 107     def run_tst_program(self, prog, initial_regs=None,
 108                               initial_mem=None,
 109                               initial_fprs=None):
 110         if initial_regs is None:
 111             initial_regs = [0] * 32
 112         simulator = run_tst(prog, initial_regs, mem=initial_mem,
 113                                   initial_fprs=initial_fprs)
 114         print ("GPRs")
 115         simulator.gpr.dump()
 116         print ("FPRs")
 117         simulator.fpr.dump()
 118         return simulator
 119
 120
 121 if __name__ == "__main__":
 122     unittest.main()