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_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 torus_pkt_strat(draw, ncols, nrows):
src_x = draw(st.integers(0, ncols - 1), label="src_x")
src_y = draw(st.integers(0, nrows - 1), label="src_y")
dst_x = draw(st.integers(0, ncols - 1), label="dst_x")
dst_y = draw(st.integers(0, nrows - 1), label="dst_y")
payload = draw(st.sampled_from([0xdeadface, 0xfaceb00c, 0xdeadbabe]))
Pkt = mk_mesh_pkt(ncols, nrows, vc=2)
return Pkt(src_x, src_y, dst_x, dst_y, 0, 0, payload)
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_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_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 mesh_pkt_strat(draw, ncols, nrows, opaque_nbits=8, vc=1, payload_nbits=32):
dst_x = draw(st.integers(0, ncols - 1))
dst_y = draw(st.integers(0, nrows - 1))
src_x = draw(st.integers(0, ncols - 1))
src_y = draw(st.integers(0, nrows - 1))
opaque = draw(pst.bits(opaque_nbits))
payload = draw(st.sampled_from([0, 0xdeadbeef, 0xfaceb00c, 0xc001cafe]))
Pkt = mk_mesh_pkt(ncols, nrows, opaque_nbits, vc, payload_nbits)
if vc == 1:
return Pkt(src_x, src_y, dst_x, dst_y, opaque, payload)
else:
return Pkt(src_x, src_y, dst_x, dst_y, opaque, 0, payload)
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 _mk_mesh_net(opts):
ncols = opts.ncols
nrows = opts.nrows
nports = opts.ncols * opts.nrows
payload_nbits = opts.channel_bw
channel_lat = opts.channel_lat
Pos = mk_mesh_pos(ncols, nrows)
Pkt = mk_mesh_pkt(ncols, nrows, vc=1, payload_nbits=payload_nbits)
if hasattr(opts, 'cl') and opts.cl:
cl_net = MeshNetworkCL(Pkt, Pos, ncols, nrows, channel_lat)
net = CLNetWrapper(Pkt, cl_net, nports)
else:
net = MeshNetworkRTL(Pkt, Pos, ncols, nrows, channel_lat)
return net
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 _mk_torus_net(opts):
ncols = opts.ncols
nrows = opts.nrows
payload_nbits = opts.channel_bw
channel_lat = opts.channel_lat
Pos = mk_mesh_pos(ncols, nrows)
Pkt = mk_mesh_pkt(ncols, nrows, vc=2, payload_nbits=payload_nbits)
net = TorusNetworkRTL(Pkt,
Pos,
ncols,
nrows,
channel_lat,
vc=2,
credit_line=2)
return net
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, 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_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=20 )
def _gen_mesh_pkt(opts, timestamp, src_id):
ncols = opts.ncols
nrows = opts.nrows
payload_nbits = opts.channel_bw
nports = ncols * nrows
x_type = mk_bits(clog2(opts.ncols))
y_type = mk_bits(clog2(opts.nrows))
pkt = mk_mesh_pkt(ncols, nrows, vc=1, payload_nbits=payload_nbits)()
pkt.payload = timestamp
dst_id = _gen_dst_id(opts.pattern, nports, src_id)
pkt.src_x = x_type(src_id % ncols)
pkt.src_y = y_type(src_id // ncols)
pkt.dst_x = x_type(dst_id % ncols)
pkt.dst_y = y_type(dst_id // ncols)
return pkt
def test_hypothesis(s, ncols, nrows, routing, pos_x, pos_y, pkts, src_init,
src_inter, sink_init, sink_inter):
# Draw some numbers
pos_x = pos_x.draw(st.integers(0, ncols - 1), label="pos_x")
pos_y = pos_y.draw(st.integers(0, nrows - 1), label="pos_y")
Pkt = mk_mesh_pkt(ncols, nrows)
router_fl = MeshRouterFL(pos_x, pos_y, dimension='x')
msgs = pkts.draw(st.lists(mesh_pkt_strat(ncols, nrows),
min_size=1,
max_size=50),
label="msgs")
src_pkts = router_fl.arrange_src_pkts(msgs)
dst_pkts = router_fl.route(src_pkts)
th = s.TestHarness(Pkt, src_pkts, dst_pkts, ncols, nrows, pos_x, pos_y)
th.set_param("top.src*.construct",
initial_delay=src_init,
interval_delay=src_init)
th.set_param("top.sink*.construct",
initial_delay=sink_init,
interval_delay=sink_init)
run_sim(th, max_cycles=5000)
def test_srcsink_mesh4x4( cmdline_opts ):
# src, dst, payload
test_msgs = [ (0, 15, 101), (1, 14, 102), (2, 13, 103), (3, 12, 104),
(4, 11, 105), (5, 10, 106), (6, 9, 107), (7, 8, 108),
(8, 7, 109), (9, 6, 110), (10, 5, 111), (11, 4, 112),
(12, 3, 113), (13, 2, 114), (14, 1, 115), (15, 0, 116) ]
src_packets = [ [],[],[],[],
[],[],[],[],
[],[],[],[],
[],[],[],[] ]
sink_packets = [ [],[],[],[],
[],[],[],[],
[],[],[],[],
[],[],[],[] ]
# note that need to yield one/two cycle for reset
arrival_pipes = [[8], [6], [6], [8],
[6], [4], [4], [6],
[6], [4], [4], [6],
[8], [6], [6], [8]]
ncols = 4
nrows = 4
PacketType = mk_mesh_pkt( ncols, nrows )
for (src, dst, payload) in test_msgs:
pkt = PacketType( src%ncols, src//ncols, dst%ncols, dst//ncols, 1, payload )
src_packets [src].append( pkt )
sink_packets[dst].append( pkt )
# for i,x in enumerate(src_packets):
# print("src", i, [str(y) for y in x] )
# for i,x in enumerate(sink_packets):
# print("sink", i, [str(y) for y in x] )
th = TestHarness( PacketType, ncols, nrows, src_packets, sink_packets,
0, 0, 0, 0 )
run_sim( th, cmdline_opts )
