gram/test/test_core_refresher.py

   1 from nmigen import *
   2 from nmigen.hdl.ast import Past
   3 from nmigen.asserts import Assert, Assume
   4
   5 from gram.core.refresher import RefreshExecuter, RefreshSequencer, RefreshTimer, RefreshPostponer, Refresher
   6 from gram.compat import *
   7 from gram.test.utils import *
   8
   9 class RefreshExecuterTestCase(FHDLTestCase):
  10     def test_executer(self):
  11         def generic_test(abits, babits, trp, trfc):
  12             dut = RefreshExecuter(abits=abits, babits=babits, trp=trp, trfc=trfc)
  13
  14             def process():
  15                 yield dut.start.eq(1)
  16                 yield; yield Delay(1e-9)
  17                 self.assertEqual((yield dut.a), 2**10)
  18                 for i in range(trp):
  19                     yield
  20                 yield Delay(1e-9)
  21                 self.assertEqual((yield dut.a), 0)
  22
  23             runSimulation(dut, process, "test_refreshexecuter.vcd")
  24
  25         generic_test(20, 20, 5, 5)
  26         generic_test(20, 20, 100, 5)
  27
  28 class RefreshSequencerTestCase(FHDLTestCase):
  29     def test_formal(self):
  30         trp = 5; trfc = 5
  31         dut = RefreshSequencer(abits=14, babits=3, trp=trp, trfc=trfc, postponing=1)
  32         self.assertFormal(dut, mode="bmc", depth=trp+trfc+1)
  33
  34 class RefreshTimerTestCase(FHDLTestCase):
  35     def test_formal(self):
  36         def generic_test(tREFI):
  37             dut = RefreshTimer(tREFI)
  38             self.assertFormal(dut, mode="bmc", depth=tREFI+1)
  39         [generic_test(_) for _ in [2, 5, 10]]
  40
  41 class RefreshPostponerTestCase(FHDLTestCase):
  42     def test_init(self):
  43         dut = RefreshPostponer(1)
  44
  45         def process():
  46             self.assertFalse((yield dut.req_o))
  47
  48         runSimulation(dut, process, "test_refreshpostponer.vcd")
  49
  50     def test_delay(self):
  51         def generic_test(delay):
  52             dut = RefreshPostponer(delay)
  53
  54             def process():
  55                 yield dut.req_i.eq(1)
  56                 yield
  57
  58                 for i in range(delay):
  59                     self.assertFalse((yield dut.req_o))
  60                     yield
  61
  62                 self.assertTrue((yield dut.req_o))
  63
  64             runSimulation(dut, process, "test_refreshpostponer.vcd")
  65
  66         [generic_test(_) for _ in [1, 5, 10]]
  67
  68     def test_req_not_stuck(self):
  69         def generic_test(delay):
  70             dut = RefreshPostponer(delay)
  71
  72             def process():
  73                 yield dut.req_i.eq(1)
  74                 yield
  75
  76                 for i in range(delay):
  77                     yield
  78
  79                 yield dut.req_i.eq(0)
  80                 yield; yield Delay(1e-9)
  81
  82                 self.assertFalse((yield dut.req_o))
  83
  84             runSimulation(dut, process, "test_refreshpostponer.vcd")
  85
  86         [generic_test(_) for _ in [1, 5, 10]]
  87
  88 class RefresherTestCase(FHDLTestCase):
  89     class Obj:
  90         pass
  91
  92     settings = Obj()
  93     settings.with_refresh = True
  94     settings.refresh_zqcs_freq = 1e0
  95     settings.timing = Obj()
  96     settings.timing.tREFI = 64
  97     settings.timing.tRP   = 1
  98     settings.timing.tRFC  = 2
  99     settings.timing.tZQCS = 64
 100     settings.geom = Obj()
 101     settings.geom.addressbits = 16
 102     settings.geom.bankbits    = 3
 103     settings.phy = Obj()
 104     settings.phy.nranks = 1
 105
 106     def test_init(self):
 107         def generic_test(postponing):
 108             dut = Refresher(self.settings, 100e6, postponing)
 109
 110             def process():
 111                 self.assertFalse((yield dut.cmd.valid))
 112
 113             runSimulation(dut, process, "test_refresher.vcd")
 114
 115         [generic_test(_) for _ in [1, 2, 4, 8]]