Example #1
0
def test_directed_cosim(cosim_cls, din_delay, dout_delay):
    dut = get_decoupled_dut(dout_delay, replicate)
    verif(drv(t=T_DIN, seq=SEQUENCE) | delay_rng(din_delay, din_delay),
          f=dut(sim_cls=cosim_cls),
          ref=replicate(name='ref_model'),
          delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #2
0
def test_array(cosim_cls, din_delay, dout_delay, size):
    ref = [list(range(i * size, (i + 1) * size)) for i in range(255 // size)]

    dut = get_decoupled_dut(dout_delay, parallelize(t=Array[Uint[8], size]))
    directed(drv(t=Uint[8], seq=itertools.chain(*ref)),
             f=dut(name='dut', sim_cls=cosim_cls),
             ref=ref,
             delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #3
0
def test_replicate_queue(cosim_cls, din_delay, dout_delay):
    dut = get_decoupled_dut(dout_delay, replicate_while)
    verif(drv(t=Bool, seq=[1, 1, 0] * 5),
          drv(t=Queue[Uint[16]], seq=[list(range(5))])
          | delay_rng(din_delay, din_delay),
          f=dut(sim_cls=cosim_cls),
          ref=replicate_while(name='ref_model'),
          delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #4
0
def test_uint(cosim_cls, din_delay, dout_delay):
    size = 8
    ref = [Uint[size](0x11), Uint[size](0x22), Uint[size](0x33)]

    dut = get_decoupled_dut(dout_delay, parallelize(t=Uint[size]))
    directed(drv(t=Bool, seq=itertools.chain(*ref)),
             f=dut(name='dut', sim_cls=cosim_cls),
             ref=ref,
             delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #5
0
def test_tuple_uint_directed(sim_cls, din_delay, cfg_delay, dout_delay):
    t_ctrl = Uint[4]
    t_din = Tuple[Uint[8], Uint[8], Uint[8]]

    dut = get_decoupled_dut(dout_delay, field_mux)
    directed(drv(t=t_ctrl, seq=[0, 1, 2])
             | delay_rng(cfg_delay, cfg_delay),
             drv(t=t_din, seq=[(5, 6, 7), (5, 6, 7), (5, 6, 7)])
             | delay_rng(din_delay, din_delay),
             f=dut(sim_cls=sim_cls),
             ref=[(5, 0), (6, 1), (7, 2)],
             delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #6
0
def test_delay(cosim_cls, din_delay, dout_delay):
    def bitfield(n):
        return [int(digit) for digit in bin(n)[2:]]

    seq = [bitfield(0x73), bitfield(0x00)]
    init = [1, 0]

    dut = get_decoupled_dut(dout_delay, reduce(f=lambda x, y: x ^ y))
    verif(drv(t=Queue[Bool], seq=seq) | delay_rng(din_delay, din_delay),
          drv(t=Uint[8], seq=init),
          f=dut(sim_cls=cosim_cls),
          ref=reduce(name='ref_model', f=lambda x, y: x ^ y),
          delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #7
0
def test_uint_directed(sim_cls, din_delay, cfg_delay, dout_delay):
    t_ctrl = Uint[4]
    t_din = Uint[8]

    dut = get_decoupled_dut(dout_delay, mux)
    directed(drv(t=t_ctrl, seq=[0, 1, 2])
             | delay_rng(cfg_delay, cfg_delay),
             drv(t=t_din, seq=[5])
             | delay_rng(din_delay, din_delay),
             drv(t=t_din, seq=[6])
             | delay_rng(din_delay, din_delay),
             drv(t=t_din, seq=[7])
             | delay_rng(din_delay, din_delay),
             f=dut(sim_cls=sim_cls),
             ref=[(5, 0), (6, 1), (7, 2)],
             delays=[delay_rng(dout_delay, dout_delay)])

    sim()
Example #8
0
def test_diff_inputs(sim_cls, din_delay, cfg_delay, dout_delay):
    t_ctrl = Uint[2]
    t_din0 = Uint[5]
    t_din1 = Int[10]
    t_din2 = Queue[Uint[8]]

    dut = get_decoupled_dut(dout_delay, mux)
    directed(drv(t=t_ctrl, seq=[0, 1, 2])
             | delay_rng(cfg_delay, cfg_delay),
             drv(t=t_din0, seq=[5])
             | delay_rng(din_delay, din_delay),
             drv(t=t_din1, seq=[6])
             | delay_rng(din_delay, din_delay),
             drv(t=t_din2, seq=[[8]])
             | delay_rng(din_delay, din_delay),
             f=dut(sim_cls=sim_cls),
             ref=[(5, 0), (6, 1), ((8, 1), 2)],
             delays=[delay_rng(dout_delay, dout_delay)])

    sim()