def test_simple_5x5(s, pos_x, pos_y, cmdline_opts):
ncols = 5
nrows = 5
Pkt = mk_mesh_pkt(ncols, nrows, vc=2)
src_pkts, sink_pkts = mk_srcsink_pkts(
pos_x,
pos_y,
ncols,
nrows,
[
# src_x y dst_x y opq vc payload
Pkt(1, 0, 0, 4, 0, 0, 0xfaceb00c),
])
th = TestHarness(Pkt, src_pkts, sink_pkts)
th.set_param(
"top.construct",
ncols=ncols,
nrows=nrows,
pos_x=pos_x,
pos_y=pos_y,
)
run_sim(th, cmdline_opts)
def test_pyh2(num_inports, num_outports, pkts, cmdline_opts):
pkts = pkts.draw(
st.lists(pkt_strat(num_inports, num_outports),
min_size=1,
max_size=100))
th = TestHarness(TestHeader, num_inports, num_outports, pkts)
run_sim(th, cmdline_opts)
def test_self_simple( cmdline_opts ): PacketType = mk_mesh_pkt(4, 4) pkt = PacketType( 0, 0, 0, 0, 0, 0xdead ) src_pkts = [ [], [], [], [], [pkt] ] sink_pkts = [ [], [], [], [], [pkt] ] th = TestHarness( PacketType, 4, 4, 0, 0, src_pkts, sink_pkts ) run_sim( th, cmdline_opts )
def test_char(k_ary, n_fly):
num_terminals = k_ary * (k_ary**(n_fly - 1))
src_packets = [[] for _ in range(k_ary)]
sink_packets = [[] for _ in range(k_ary)]
payload_wid = 32
BEGIN = clog2(k_ary) * n_fly - clog2(k_ary)
END = clog2(k_ary) * n_fly
src = 0
PacketType = mk_bfly_pkt(k_ary, n_fly)
pkt_n = 25
for _ in range(pkt_n):
for di in range(k_ary):
dst = di * (k_ary**(n_fly - 1))
bf_dst = set_dst(k_ary, n_fly, dst)
payload = random.randint(0, 2**payload_wid)
pkt = PacketType(src, bf_dst, 0, payload)
src_packets[src % k_ary].append(pkt)
# print( bf_dst, pkt.dst[ BEGIN : END ] )
sink_packets[pkt.dst[BEGIN:END]].append(pkt)
pos_row = 1
pos_fly = 0
th = TestHarness(PacketType, k_ary, n_fly, pos_row, pos_fly, src_packets,
sink_packets, 0, 0, 0, 0)
run_sim(th,
cmdline_opts={
'dump_vcd': False,
'test_verilog': 'zeros',
'dump_vtb': False
})
def test_random(src_number):
k_ary = 10
n_fly = 1
num_terminals = k_ary * (k_ary**(n_fly - 1))
src_packets = [[] for _ in range(k_ary)]
sink_packets = [[] for _ in range(k_ary)]
payload_wid = 32
BEGIN = clog2(k_ary) * n_fly - clog2(k_ary)
END = clog2(k_ary) * n_fly
src = src_number
pkt_n = 25
for index in range(pkt_n // k_ary):
for di in range(k_ary):
dst = di * (k_ary**(n_fly - 1))
# src = random.randint( 0, k_ary - 1 )
# dst = random.randint( 0, num_terminals - 1 )
PacketType = mk_bfly_pkt(k_ary, n_fly)
bf_dst = set_dst(k_ary, n_fly, dst)
payload = random.randint(0, 2**payload_wid)
pkt = PacketType(src, bf_dst, 0, payload)
src_packets[src % k_ary].append(pkt)
sink_packets[pkt.dst[BEGIN:END]].append(pkt)
pos_row = 1
pos_fly = 0
th = TestHarness(PacketType, k_ary, n_fly, pos_row, pos_fly, src_packets,
sink_packets, 0, 0, 0, 0)
# th.set_param( "top.dut.route_units*.construct", n_fly=n_fly )
# th.set_param( "top.dut.line_trace", )
run_sim(th)
def actual_test(dwid, qsize, qtype, sink_init, test_msgs):
msgs = test_msgs.draw(
st.lists(pst.bits(dwid), min_size=1, max_size=100))
th = s.TestHarness(mk_bits(dwid), msgs, msgs)
th.set_param("top.sink.construct", initial_delay=sink_init)
th.set_param("top.dut.construct", QueueType=qtype)
th.set_param("top.dut.queue.construct", num_entries=qsize)
run_sim(th, max_cycles=5000)
def test_mflit_mesh_router(test_params, cmdline_opts):
ref = PitonRouterFL(test_params.pos_x, test_params.pos_y)
pkts = test_params.msg_func(test_params.pos_x, test_params.pos_y)
src_pkts = ref.arrange_src_pkts(pkts)
dst_pkts = ref.route(src_pkts)
th = TestHarness(test_params.pos_x, test_params.pos_y, src_pkts, dst_pkts)
run_sim(th, cmdline_opts)
def test_simple():
Pkt = mk_generic_pkt(vc=2, payload_nbits=32)
msgs = [
Pkt(0, 1, 0x04, 0, 0xdeadbabe),
Pkt(0, 2, 0x02, 1, 0xfaceb00c),
Pkt(0, 3, 0x03, 0, 0xdeadface),
]
th = TestHarness(Pkt, msgs, msgs)
run_sim(th)
def test_piton_mesh(test_params, cmdline_opts):
ncols = test_params.ncols
nrows = test_params.nrows
pkts = test_params.msg_func(ncols, nrows)
src_pkts, dst_pkts = arrange_src_sink_pkts(ncols, nrows, pkts)
th = TestHarness(ncols, nrows, src_pkts, dst_pkts)
run_sim(th, cmdline_opts)
def test_sflit_xbar(test_params, cmdline_opts):
pkts = test_params.msg_func(test_params.n_in, test_params.n_out)
th = TestHarness(test_params.n_in, test_params.n_out, pkts)
th.set_param(
'top.sink*.construct',
initial_delay=test_params.init,
interval_delay=test_params.intv,
)
run_sim(th, cmdline_opts)
def test_4pkt():
pkts= [
mk_pkt( False, 1, 0, [ ] ),
mk_pkt( False, 1, 2, [ 0xfaceb00c, 0x8badf00d ] ),
mk_pkt( False, 0, 1, [ 0xdeadbeef ] ),
mk_pkt( False, 2, 1, [ 0xcafef00d, 0x111edcba, 0xbaaaaaad ] ),
]
th = TestHarness( PitonPosition, pkts, 1, 1 )
th.set_param( 'top.src.construct', packet_interval_delay = 1 )
run_sim( th, max_cycles=20 )
def test_su5_simple(s):
src_msgs = [[] for _ in range(5)]
src_msgs[0] = [b16(4), b16(5)]
src_msgs[1] = [b16(2), b16(8)]
src_msgs[2] = [b16(4), b16(13)]
src_msgs[3] = [b16(6), b16(18)]
src_msgs[4] = [b16(8), b16(23)]
sink_msg = [msg for i in range(5) for msg in src_msgs[i]]
th = s.TestHarness(Bits16, src_msgs, sink_msg, num_inports=5)
run_sim(th)
def test_mflit_mesh_router(test_params, cmdline_opts):
ref = MeshRouterMflitFL(TestHeader, test_params.pos_x, test_params.pos_y)
pkts = test_params.msg_func(test_params.pos_x, test_params.pos_y)
src_pkts = ref.arrange_src_pkts(pkts)
dst_pkts = ref.route(src_pkts)
th = TestHarness(TestHeader, TestPosition, test_params.pos_x,
test_params.pos_y, src_pkts, dst_pkts)
run_sim(th, cmdline_opts)
def test_mflit_mesh( test_params, cmdline_opts ):
ncols = test_params.ncols
nrows = test_params.nrows
pkts = test_params.msg_func( ncols, nrows )
src_pkts, dst_pkts = arrange_src_sink_pkts( TestHeader, ncols, nrows, pkts )
th = TestHarness( TestHeader, TestPosition, ncols, nrows,
src_pkts, dst_pkts )
run_sim( th, cmdline_opts )
def test_4pkt(cmdline_opts):
pkts = [
mk_pkt(1, 0, []),
mk_pkt(1, 2, [0xfaceb00c, 0x8badf00d]),
mk_pkt(0, 1, [0xdeadbeef]),
mk_pkt(2, 1, [0xcafef00d, 0x111edcba, 0xbaaaaaad]),
]
th = TestHarness(TestHeader, TestPosition, pkts, 1, 1)
th.set_param('top.src.construct', packet_interval_delay=1)
run_sim(th, cmdline_opts, max_cycles=20)
def test_xbar_route(test_params, cmdline_opts):
pkts = test_params.msg_func(test_params.n_outs)
th = TestHarness(TestHeader, test_params.n_outs, pkts)
th.set_param(
'top.sink*.construct',
initial_delay=test_params.init,
flit_interval_delay=test_params.flit_intv,
packet_interval_delay=test_params.pkt_intv,
)
run_sim(th, cmdline_opts)
def test_hypothesis(s, ncols, nrows, pkts, cmdline_opts):
Pkt = mk_mesh_pkt(ncols, nrows, vc=2)
pkts_lst = pkts.draw(st.lists(torus_pkt_strat(ncols, nrows),
max_size=4),
label="pkts")
src_pkts = mk_src_pkts(ncols, nrows, pkts_lst)
dst_pkts = torusnet_fl(ncols, nrows, src_pkts)
th = TestHarness(Pkt, ncols, nrows, src_pkts, dst_pkts)
run_sim(th, cmdline_opts, max_cycles=5000)
def test_simple4x4(s, pos_x, pos_y):
ncols = 4
nrows = 4
Pkt = mk_mesh_pkt(ncols, nrows)
router_fl = MeshRouterFL(pos_x, pos_y, dimension='x')
src_pkts = router_fl.arrange_src_pkts([
# src_x y dst_x y opq payload
Pkt(0, 0, 3, 3, 0, 0xdeaddead),
])
dst_pkts = router_fl.route(src_pkts)
th = s.TestHarness(Pkt, src_pkts, dst_pkts, ncols, nrows, pos_x, pos_y)
run_sim(th)
def test_normal_simple( cmdline_opts ):
src_packets = [[],[],[],[],[]]
for item in test_msgs:
for i in range( len( item ) ):
(dst_x,dst_y,payload,dir_out) = item[i]
PacketType = mk_mesh_pkt (4, 4)
pkt = PacketType (0, 0, dst_x, dst_y, 1, payload)
src_packets[i].append( pkt )
result_msgs[dir_out].append( pkt )
th = TestHarness( PacketType, 4, 4, 1, 1, src_packets, result_msgs, 0, 0, 0, 0 )
run_sim( th, cmdline_opts )
def test_basic(cmdline_opts):
msgs = [
0xfaceb00c,
2,
0xdeadbeef,
1,
0xcafebabefa11deaf,
4,
0xace3ace2ace1ace0,
3,
]
th = TestHarness(16, 4, msgs)
run_sim(th, cmdline_opts, max_cycles=20)
def test_backpressure(cmdline_opts):
msgs = [
0xfaceb00c,
2,
0xdeadbeef,
1,
0xcafebabefa11deaf,
4,
0xace3ace2ace1ace0,
3,
]
th = TestHarness(16, 4, msgs)
th.set_param('top.sink.construct', initial_delay=10, interval_delay=2)
run_sim(th, cmdline_opts, max_cycles=40)
def test_src_delay(cmdline_opts):
msgs = [
0xdeadbeef_faceb00c,
2,
0xbad0bad0_deadbeef,
1,
0xcafebabe_fa11deaf_deadc0de_faceb00c,
4,
0xace5ace4_ace3ace2_ace1ace0,
3,
]
th = TestHarness(32, 9, msgs)
th.set_param('top.src*.construct', initial_delay=10, interval_delay=2)
run_sim(th, cmdline_opts, max_cycles=200)
def test_pyh2(in_nbits, max_nblocks, data, cmdline_opts):
len_msgs = data.draw(
st.lists(st.integers(1, max_nblocks), min_size=1, max_size=100))
src_msgs = [
data.draw(st.integers(0, 2**(x * in_nbits) - 1)) for x in len_msgs
]
msgs = []
for x, l in zip(src_msgs, len_msgs):
msgs.append(x)
msgs.append(l)
th = TestHarness(in_nbits, max_nblocks, msgs)
run_sim(th, cmdline_opts)
def test_h1(s):
pos_x = 0
pos_y = 0
ncols = 2
nrows = 2
Pkt = mk_mesh_pkt(ncols, nrows)
router_fl = MeshRouterFL(pos_x, pos_y, dimension='x')
src_pkts = router_fl.arrange_src_pkts([
# src_x y dst_x y opq payload
Pkt(0, 0, 0, 1, 0, 0xdeadbabe),
])
dst_pkts = router_fl.route(src_pkts)
th = s.TestHarness(Pkt, src_pkts, dst_pkts, ncols, nrows, pos_x, pos_y)
run_sim(th)
def test_h1( cmdline_opts ):
pos_x, pos_y, ncols, nrows = 0, 0, 2, 2
PacketType = mk_mesh_pkt( ncols, nrows )
pkt0 = PacketType( 0, 0, 0, 1, 0, 0xdead )
src_pkts = [ [], [], [], [], [pkt0] ]
sink_pkts = [ [pkt0], [], [], [], [] ]
th = TestHarness(
PacketType, ncols, nrows, pos_x, pos_y,
src_pkts, sink_pkts
)
th.set_param(
"top.dut.construct",
RouteUnitType = DORYMeshRouteUnitRTL
)
run_sim( th, cmdline_opts )
def test_backpresure():
Pkt = mk_generic_pkt(vc=2, payload_nbits=32)
msgs = [
# src dst opq vc_id payload
Pkt(0, 1, 0x04, 0, 0xdeadbabe),
Pkt(0, 2, 0x02, 1, 0xfaceb00c),
Pkt(0, 3, 0x03, 0, 0xdeadface),
Pkt(0, 3, 0x03, 1, 0xdeadface),
Pkt(0, 3, 0x03, 1, 0xdeadface),
Pkt(0, 3, 0x03, 0, 0xdeadface),
Pkt(0, 3, 0x03, 0, 0xdeadface),
]
th = TestHarness(Pkt, msgs, msgs)
th.set_param("top.sink.construct", initial_delay=20)
run_sim(th)
def _test_simple(s, translation=''):
nterminals = 4
Pkt = mk_ring_pkt(nterminals)
src_pkts = mk_src_pkts(
nterminals,
[
# src dst opq vc payload
Pkt(3, 0, 0, 0, 0xfaceb00c),
])
dst_pkts = ringnet_fl(src_pkts)
th = TestHarness(Pkt, nterminals, src_pkts, dst_pkts)
cmdline_opts = {
'dump_vcd': False,
'test_verilog': translation,
'dump_vtb': False
}
run_sim(th, cmdline_opts)
def test_simple(s, cmdline_opts):
ncols = 2
nrows = 2
Pkt = mk_mesh_pkt(ncols, nrows, vc=2)
src_pkts = mk_src_pkts(
ncols,
nrows,
[
# src_x y dst_x y opq vc payload
Pkt(1, 0, 0, 1, 0, 0, 0xfaceb00c),
Pkt(1, 1, 1, 0, 0, 0, 0xdeadface),
])
dst_pkts = torusnet_fl(ncols, nrows, src_pkts)
th = TestHarness(Pkt, ncols, nrows, src_pkts, dst_pkts)
run_sim(th, cmdline_opts)
def test_mesh_simple( test_params ):
PktType = mk_mesh_pkt( ncols=test_params.wid,
nrows=test_params.ht, vc=1 )
src_msgs, sink_msgs = mk_src_sink_msgs( PktType, test_params.msg_list,
test_params.wid, test_params.ht )
th = TestHarness(
PktType,
test_params.wid,
test_params.ht,
src_msgs,
sink_msgs,
test_params.src_init,
test_params.src_intv,
test_params.sink_init,
test_params.sink_intv,
)
run_sim( th )
def test_h2( cmdline_opts ):
pos_x, pos_y, ncols, nrows = 0, 0, 2, 2
PacketType = mk_mesh_pkt( ncols, nrows )
pkt0 = PacketType( 0, 0, 1, 0, 0, 0xdead )
pkt1 = PacketType( 0, 1, 1, 0, 1, 0xbeef )
pkt2 = PacketType( 0, 1, 1, 0, 2, 0xcafe )
# N S W E self
src_pkts = [ [pkt1, pkt2], [], [], [], [pkt0] ]
sink_pkts = [ [], [], [], [pkt1, pkt0, pkt2], [] ]
th = TestHarness(
PacketType, ncols, nrows, pos_x, pos_y,
src_pkts, sink_pkts
)
th.set_param(
"top.dut.construct",
RouteUnitType = DORYMeshRouteUnitRTL
)
run_sim( th, cmdline_opts, max_cycles=10 )
