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_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 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_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 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_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_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_basic( cmdline_opts ):
msgs = [
0xfaceb00c, 2,
0xdeadbeef, 1,
0xcafebabefa11deaf, 4,
0xace3ace2ace1ace0, 3,
]
th = TestHarness( 16, 4, msgs )
run_sim( th, cmdline_opts, max_cycles=40 )
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_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_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_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_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_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_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_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=40 )
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_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_pyh2( out_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*out_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( out_nbits, max_nblocks, msgs )
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_stream( cmdline_opts ):
msgs = [
0xdeadbeef, 1,
0xbad0bad0, 1,
0xcafebabe, 1,
0xace5ace4, 1,
0xfaceb00c_ace5ace4, 2,
0x8badf00d_ace5ace4, 2,
0x8badc0de_ace5ace4, 2,
0xfeedbabe_ace5ace4, 2,
]
th = TestHarness( 32, 4, msgs )
run_sim( th, cmdline_opts, max_cycles=40 )
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_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_simple_4x4( s, pos_x, pos_y, cmdline_opts ):
ncols = 4
nrows = 4
Pkt = mk_mesh_pkt( ncols, nrows, vc=2 )
src_pkts = [
# src_x y dst_x y opq vc payload
Pkt( 0, 0, 1, 1, 0, 0, 0xfaceb00c ),
Pkt( 0, 0, 0, 0, 0, 0, 0xdeaddead ),
Pkt( 0, 0, 1, 0, 0, 0, 0xdeadface ),
Pkt( 0, 0, 3, 3, 0, 0, 0xdeadface ),
]
dst_pkts = mk_dst_pkts( pos_x, pos_y, ncols, nrows, src_pkts )
th = TestHarness( Pkt, src_pkts, dst_pkts, ncols, nrows, pos_x, pos_y )
run_sim( th, cmdline_opts )
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)
