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)