src/add/test_add64.py

   1 from nmigen import Module, Signal
   2 from nmigen.compat.sim import run_simulation
   3
   4 from nmigen_add_experiment import FPADD
   5
   6 import sys
   7 import atexit
   8 from random import randint
   9 from random import seed
  10
  11 from unit_test_double import (get_mantissa, get_exponent, get_sign, is_nan,
  12                                 is_inf, is_pos_inf, is_neg_inf,
  13                                 match, get_case, check_case, run_test)
  14
  15
  16 def testbench(dut):
  17     yield from check_case(dut, 0, 0, 0)
  18     yield from check_case(dut, 0x3FF0000000000000, 0x4000000000000000,
  19                                0x4008000000000000)
  20     yield from check_case(dut, 0x4000000000000000, 0x3FF0000000000000,
  21                                0x4008000000000000)
  22     yield from check_case(dut, 0x4056C00000000000, 0x4042800000000000,
  23                                0x4060000000000000)
  24     yield from check_case(dut, 0x4056C00000000000, 0x4042EA3D70A3D70A,
  25                                0x40601A8F5C28F5C2)
  26
  27     count = 0
  28
  29     #regression tests
  30     stimulus_a = [0x3ff00000000000c5, 0xff80000000000000]
  31     stimulus_b = [0xbd28a404211fb72b, 0x7f80000000000000]
  32     yield from run_test(dut, stimulus_a, stimulus_b)
  33     count += len(stimulus_a)
  34     print (count, "vectors passed")
  35
  36     #corner cases
  37     from itertools import permutations
  38     stimulus_a = [i[0] for i in permutations([
  39         0x8000000000000000,
  40         0x0000000000000000,
  41         0x7ff8000000000000,
  42         0xfff8000000000000,
  43         0x7ff0000000000000,
  44         0xfff0000000000000
  45     ], 2)]
  46     stimulus_b = [i[1] for i in permutations([
  47         0x8000000000000000,
  48         0x0000000000000000,
  49         0x7ff8000000000000,
  50         0xfff8000000000000,
  51         0x7ff0000000000000,
  52         0xfff0000000000000
  53     ], 2)]
  54     yield from run_test(dut, stimulus_a, stimulus_b)
  55     count += len(stimulus_a)
  56     print (count, "vectors passed")
  57
  58     #edge cases
  59     stimulus_a = [0x8000000000000000 for i in range(1000)]
  60     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
  61     yield from run_test(dut, stimulus_a, stimulus_b)
  62     count += len(stimulus_a)
  63     print (count, "vectors passed")
  64
  65     stimulus_a = [0x0000000000000000 for i in range(1000)]
  66     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
  67     yield from run_test(dut, stimulus_a, stimulus_b)
  68     count += len(stimulus_a)
  69     print (count, "vectors passed")
  70
  71     stimulus_b = [0x8000000000000000 for i in range(1000)]
  72     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
  73     yield from run_test(dut, stimulus_a, stimulus_b)
  74     count += len(stimulus_a)
  75     print (count, "vectors passed")
  76
  77     stimulus_b = [0x0000000000000000 for i in range(1000)]
  78     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
  79     yield from run_test(dut, stimulus_a, stimulus_b)
  80     count += len(stimulus_a)
  81     print (count, "vectors passed")
  82
  83     stimulus_a = [0x7FF8000000000000 for i in range(1000)]
  84     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
  85     yield from run_test(dut, stimulus_a, stimulus_b)
  86     count += len(stimulus_a)
  87     print (count, "vectors passed")
  88
  89     stimulus_a = [0xFFF8000000000000 for i in range(1000)]
  90     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
  91     yield from run_test(dut, stimulus_a, stimulus_b)
  92     count += len(stimulus_a)
  93     print (count, "vectors passed")
  94
  95     stimulus_b = [0x7FF8000000000000 for i in range(1000)]
  96     stimulus_a = [randint(0, 1<<64) for i in range(1000)]
  97     yield from run_test(dut, stimulus_a, stimulus_b)
  98     count += len(stimulus_a)
  99     print (count, "vectors passed")
 100
 101     stimulus_b = [0xFFF8000000000000 for i in range(1000)]
 102     stimulus_a = [randint(0, 1<<64) for i in range(1000)]
 103     yield from run_test(dut, stimulus_a, stimulus_b)
 104     count += len(stimulus_a)
 105     print (count, "vectors passed")
 106
 107     stimulus_a = [0x7FF0000000000000 for i in range(1000)]
 108     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 109     yield from run_test(dut, stimulus_a, stimulus_b)
 110     count += len(stimulus_a)
 111     print (count, "vectors passed")
 112
 113     stimulus_a = [0xFFF0000000000000 for i in range(1000)]
 114     stimulus_b = [randint(0, 1<<64)  for i in range(1000)]
 115     yield from run_test(dut, stimulus_a, stimulus_b)
 116     count += len(stimulus_a)
 117     print (count, "vectors passed")
 118
 119     stimulus_b = [0x7FF0000000000000 for i in range(1000)]
 120     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 121     yield from run_test(dut, stimulus_a, stimulus_b)
 122     count += len(stimulus_a)
 123     print (count, "vectors passed")
 124
 125     stimulus_b = [0xFFF0000000000000 for i in range(1000)]
 126     stimulus_a = [randint(0, 1<<64)  for i in range(1000)]
 127     yield from run_test(dut, stimulus_a, stimulus_b)
 128     count += len(stimulus_a)
 129     print (count, "vectors passed")
 130
 131     #seed(0)
 132     for i in range(100000):
 133         stimulus_a = [randint(0, 1<<64) for i in range(1000)]
 134         stimulus_b = [randint(0, 1<<64) for i in range(1000)]
 135         yield from run_test(dut, stimulus_a, stimulus_b)
 136         count += 1000
 137         print (count, "random vectors passed")
 138
 139
 140 if __name__ == '__main__':
 141     dut = FPADD(width=64, single_cycle=True)
 142     run_simulation(dut, testbench(dut), vcd_name="test_add64.vcd")
 143