def test_footer(self, randomized=False):
self.instantiate(structStreamAndFooter,
DATA_WIDTH=16,
randomized=randomized)
u = self.u
def mk_footer(d):
v = 0
for i in range(4):
v |= (d + i) << (8 * i)
return v
axis_send_bytes(u.dataIn.data, [1, 2])
u.dataIn.footer._ag.data.append(mk_footer(3))
axis_send_bytes(u.dataIn.data, [8, 9, 10, 11])
u.dataIn.footer._ag.data.append(mk_footer(12))
t = 170
if randomized:
t *= 3
self.runSim(t * Time.ns)
offset, f = axis_recieve_bytes(u.dataOut)
self.assertEqual(offset, 0)
self.assertValSequenceEqual(f, list(range(1, 3 + 4)))
offset, f = axis_recieve_bytes(u.dataOut)
self.assertEqual(offset, 0)
self.assertValSequenceEqual(f, list(range(8, 12 + 4)))
self.assertEmpty(u.dataOut._ag.data)
def test_unionDifferentMask(self, N=10, randomized=False):
self.instantiate(unionDifferentMask,
DATA_WIDTH=16,
randomized=randomized,
use_keep=False,
use_strb=True)
u = self.u
MAGIC = 0 # 13
t = 10 + N
if randomized:
t *= 3
ref = []
for i in range(N):
i += MAGIC
if self._rand.getrandbits(1):
d = (1, [
i,
])
u.dataIn.u1.data._ag.data.append(i)
u.dataIn._select._ag.data.append(1)
else:
d = (0, [
i,
])
u.dataIn.u0.data._ag.data.append(i)
u.dataIn._select._ag.data.append(0)
ref.append(d)
self.runSim(t * CLK_PERIOD)
for i, ref_f in enumerate(ref):
ref_offset, ref_data = ref_f
f_offset, f = axis_recieve_bytes(u.dataOut)
self.assertEqual(f_offset, ref_offset)
self.assertValSequenceEqual(f, ref_data)
def test_no_args(self):
u = self.compileSimAndStart(_example_AxiS_strFormat_no_args())
self.randomize(u.out)
self.runSim(50 * CLK_PERIOD)
for _ in range(3):
frame = axis_recieve_bytes(u.out)
s = bytes(frame[1]).decode("utf-8")
self.assertEqual(s, 'test 1234')
def test_args_numbers(self):
u = self.compileSimAndStart(_example_AxiS_strFormat_args_numbers())
self.runSim(200 * CLK_PERIOD)
for _ in range(3):
frame = axis_recieve_bytes(u.out)
s = bytes(frame[1]).decode("utf-8")
self.assertEqual(
s,
"0b{0:08b}, 0o{0:04o}, {0:03d}, 0x{0:02x}, 0x{0:02X}".format(
13))
def test_1x_str(self):
u = self.compileSimAndStart(_example_AxiS_strFormat_1x_str())
self.randomize(u.out)
self.randomize(u.str0)
strings = ["test0", "x", "1234567890"]
for s in strings:
axis_send_bytes(u.str0, s.encode("utf-8"))
self.runSim(200 * CLK_PERIOD)
for s_ref in strings:
frame = axis_recieve_bytes(u.out)
s = bytes(frame[1]).decode("utf-8")
self.assertEqual(s, "str0:{0:s}".format(s_ref))
def test_1Field_halfvalid(self, randomized=False):
self.instantiate(s1field, DATA_WIDTH=128, randomized=randomized)
u = self.u
MAGIC = 3
u.dataIn.item0._ag.data.append(MAGIC)
t = 100
if randomized:
t *= 2
self.runSim(t * Time.ns)
offset, f = axis_recieve_bytes(u.dataOut)
self.assertEqual(offset, 0)
self.assertSequenceEqual(f, [MAGIC, 0, 0, 0, 0, 0, 0, 0])
def test_3x_str(self):
u = self.compileSimAndStart(_example_AxiS_strFormat_3x_str())
self.randomize(u.out)
self.randomize(u.str0)
self.randomize(u.str1)
self.randomize(u.str2)
strings = [("test0", "str1", "str3"), ("x", "y", "z"),
("1234567890", "abc", "\t\n")]
for s0, s1, s2 in strings:
axis_send_bytes(u.str0, s0.encode("utf-8"))
axis_send_bytes(u.str1, s1.encode("utf-8"))
axis_send_bytes(u.str2, s2.encode("utf-8"))
self.runSim(200 * CLK_PERIOD)
for s_ref in strings:
frame = axis_recieve_bytes(u.out)
s = bytes(frame[1]).decode("utf-8")
self.assertEqual(s, "{0:s}{1:s}xyz{2:s}".format(*s_ref))
def test_single(self):
u = self.u
rx_frame_bytes = list(chain(REF_FRAME, REF_CRC))
t = uint8_t[len(rx_frame_bytes)]
# :attention: strb signal is reinterpreted as a keep signal
rx_data = packAxiSFrame(self.DW,
t.from_py(rx_frame_bytes),
withStrb=True)
if u.USE_STRB:
rx_data_for_agent = ((d, m, 0, last) for d, m, last in rx_data)
else:
rx_data_for_agent = ((d, 0, last) for d, _, last in rx_data)
u.phy_rx._ag.data.extend(rx_data_for_agent)
self.runSim(CLK_PERIOD * (2 * len(u.phy_rx._ag.data) + 10))
o, f = axis_recieve_bytes(u.eth.rx)
self.assertEqual(o, 0)
self.assertValSequenceEqual(f, REF_FRAME)
self.assertEmpty(u.eth.rx._ag.data)
def test_const_size_stream(self, dataWidth, frame_len, randomize):
T = HStruct(
(HStream(Bits(8), frame_len=frame_len), "frame0"),
(uint16_t, "footer"),
)
u = self.mySetUp(dataWidth, T, randomize, use_strb=True)
u.dataIn._ag.data.extend(
packAxiSFrame(dataWidth,
T.from_py({"frame0": [i + 1 for i in range(frame_len)],
"footer": 2}),
withStrb=True,
)
)
t = 20
if randomize:
t *= 3
self.runMatrixSim2(t, dataWidth, frame_len, randomize)
off, f = axis_recieve_bytes(u.dataOut.frame0)
self.assertEqual(off, 0)
self.assertValSequenceEqual(f, [i + 1 for i in range(frame_len)])
self.assertValSequenceEqual(u.dataOut.footer._ag.data, [2])
def test_struct2xStream8(self,
randomized=False,
sizes=[(2, 2), (1, 2), (1, 3), (2, 1), (2, 2)]):
self.instantiate(struct2xStream8, DATA_WIDTH=16, randomized=randomized)
u = self.u
MAGIC = 0 # 13
t = 10 + (2 * sum(sum(x) for x in sizes) * 3)
if randomized:
t *= 3
ref = []
for i, size in enumerate(sizes):
o = MAGIC + i * 6 + 1
d0 = [o + i for i in range(size[0])]
axis_send_bytes(u.dataIn.streamIn0, d0)
d1 = [o + i + size[0] for i in range(size[1])]
axis_send_bytes(u.dataIn.streamIn1, d1)
ref.append(list(chain(d0, d1)))
self.runSim(t * CLK_PERIOD)
for i, ref_f in enumerate(ref):
f_offset, f = axis_recieve_bytes(u.dataOut)
self.assertValEqual(f_offset, 0)
self.assertValSequenceEqual(f, ref_f, i)
def _test_pass_data(self, IN_FRAMES):
OUT_FRAMES = []
for f_i in range(len(IN_FRAMES[0])):
offset = self.u.OUT_OFFSET
data = []
for in_frames in IN_FRAMES:
fdata = in_frames[f_i][1]
data.extend(fdata)
OUT_FRAMES.append((offset, data))
for i, frames in enumerate(IN_FRAMES):
for f_offset, frame in frames:
self.send(i, frame, offset=f_offset)
self.runSim(CLK_PERIOD * (
len(IN_FRAMES) * len(OUT_FRAMES[0]) * 20 + 100))
for (ref_offset, ref_frame) in OUT_FRAMES:
offset, frame = axis_recieve_bytes(self.u.dataOut)
self.assertEqual(offset, ref_offset)
self.assertSequenceEqual(frame, ref_frame)
self.assertEmpty(self.u.dataOut._ag.data)
def test_stream_and_footer(self, dataWidth, frame_len, prefix_suffix_as_padding, randomize):
"""
:note: Footer separation is tested in AxiS_footerSplitTC
and this test only check that the AxiS_frameParser can connect
wires correctly
"""
prefix_padding, suffix_padding = prefix_suffix_as_padding
T = HStruct(
(HStream(Bits(8)), "frame0"),
(uint16_t, "footer"),
)
fieldsToUse = set()
if not prefix_padding:
fieldsToUse.add("frame0")
if not suffix_padding:
fieldsToUse.add("footer")
_T = HdlType_select(T, fieldsToUse)
u = self.mySetUp(dataWidth, _T, randomize, use_strb=True)
v = T.from_py({
"frame0": [i + 1 for i in range(frame_len)],
"footer": frame_len + 1
})
u.dataIn._ag.data.extend(
packAxiSFrame(dataWidth, v, withStrb=True)
)
t = 20
if randomize:
t *= 3
self.runMatrixSim2(t, dataWidth, frame_len, randomize)
if not prefix_padding:
off, f = axis_recieve_bytes(u.dataOut.frame0)
self.assertEqual(off, 0)
self.assertValSequenceEqual(f, [i + 1 for i in range(frame_len)])
if not suffix_padding:
self.assertValSequenceEqual(u.dataOut.footer._ag.data, [frame_len + 1])
def pop_tx_frame(self):
return axis_recieve_bytes(self.u.phy_tx)
def test_simpleUnalignedWithData(self, N=1, WORDS=1, randomize=False):
u = self.u
req = u.driver._ag.req
aw = u.axi.aw._ag.data
wIn = u.driver.w._ag
w = u.axi.w._ag.data
b = u.axi.b._ag.data
if randomize:
self.randomize(u.driver.req)
self.randomize(u.driver.w)
self.randomize(u.axi.aw)
self.randomize(u.axi.w)
self.randomize(u.axi.b)
addr_step = u.DATA_WIDTH // 8
ref_w_frames = []
for i in range(N):
req.data.append(self.mkReq(0x101 + i * addr_step, WORDS - 1))
frame = []
for i2 in range(WORDS):
isLast = (i2 == WORDS - 1)
n0 = 0x10 * i2 + 0x20 + i
n1 = 0x10 * i2 + 0x10 + i
# aligned input data word
wIn.data.append(
((n1 <<
((addr_step - 1) * 8)) | n0, mask(addr_step), isLast))
frame.extend([
n0,
0,
0,
0,
0,
0,
0,
n1,
])
ref_w_frames.append(frame)
b.append(self.bTrans(RESP_OKAY, 0))
t = (15 + N) * CLK_PERIOD
if randomize:
t *= 6
self.runSim(t)
if u.ALIGNAS == u.DATA_WIDTH:
# unsupported alignment check if error is set
self.assertEmpty(aw)
self.assertValEqual(u.errorAlignment._ag.data[-1], 1)
else:
aw_ref = []
if u.axi.LEN_WIDTH == 0:
for i in range(N):
for w_i in range(WORDS + 1):
aw_ref.append(
self.aTrans(0x100 + (i + w_i) * addr_step, WORDS,
0))
else:
for i in range(N):
aw_ref.append(self.aTrans(0x100 + i * addr_step, WORDS, 0))
self.assertValSequenceEqual(aw, aw_ref)
for ref_frame in ref_w_frames:
if hasattr(u.axi.w, "id"):
offset, id_, w_data = axis_recieve_bytes(u.axi.w)
self.assertEqual(id_, 0)
elif u.axi.LEN_WIDTH == 0:
offset = None
w_data = []
for w_i in range(WORDS + 1):
data, strb = w.popleft()
for B_i in range(addr_step):
if strb[B_i]:
if offset is None:
offset = B_i + (addr_step * w_i)
B = int(data[(B_i + 1) * 8:B_i * 8])
w_data.append(B)
else:
offset, w_data = axis_recieve_bytes(u.axi.w)
self.assertEqual(offset, 1)
self.assertSequenceEqual(w_data, ref_frame)
self.assertEmpty(w)
self.assertEmpty(b)
def recive(self):
return axis_recieve_bytes(self.u.dataOut)
def assertFrameEqual(self, output_i, ref_offset, ref_data):
off, data = axis_recieve_bytes(self.u.dataOut[output_i])
self.assertEqual(off, ref_offset)
self.assertValSequenceEqual(data, ref_data)
