def reader():
payload_aa = payload_a
for i in range(32 * 12 // 64):
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (payload_aa & 0xffff_ffff_ffff_ffff, 0 if i < 5 else 1))
payload_aa = payload_aa >> 64
payload_bb = payload_b
for i in range(32 * 12 // 64):
print(i)
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (payload_bb & 0xffff_ffff_ffff_ffff, 0))
payload_bb = payload_bb >> 64
def reader():
for i in range(100):
got = (yield from read_from_stream(dut.output, extract="payload"))
print(got)
self.assertEqual(got, i)
if i % 3 == 0:
yield from do_nothing()
def axil_write(axi, addr, data, timeout=100):
yield from write_to_stream(axi.write_address, payload=addr)
yield from write_to_stream(axi.write_data, payload=data)
response = (yield from read_from_stream(axi.write_response,
extract="resp",
timeout=timeout))
assert AxiResponse.OKAY.value == response
def axil_read(axi, addr, timeout=100):
yield from write_to_stream(axi.read_address, payload=addr)
value, response = (yield from read_from_stream(axi.read_data,
extract=("payload", "resp"),
timeout=timeout))
assert AxiResponse.OKAY.value == response
return value
def reader():
last_count = 0
for i in range(200):
last_count += (yield from read_from_stream(dut.output, extract="last"))
if i % 10 == 0:
yield from do_nothing()
self.assertEqual(last_count, 10)
def reader():
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b100000000000, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000000001, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000000010, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000000100, 1))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000001000, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000010000, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000000100000, 0))
self.assertEqual((yield from read_from_stream(dut.output, extract=("payload", "last"))), (0b000001000000, 0))
def read_process():
for i in range(128):
data, last = (yield from
read_from_stream(reader.output,
extract=("payload", "last")))
assert data == i + 2
assert last == ((i % 8) == 0)
yield Passive()
def reader():
self.assertEqual((yield from read_from_stream(dut.output)), 0b001)
self.assertEqual((yield from read_from_stream(dut.output)), 0b010)
self.assertEqual((yield from read_from_stream(dut.output)), 0b100)
self.assertEqual((yield from read_from_stream(dut.output)), 0b011)
self.assertEqual((yield from read_from_stream(dut.output)), 0b110)
self.assertEqual((yield from read_from_stream(dut.output)), 0b111)
self.assertEqual((yield from read_from_stream(dut.output)), 0b000)
def reader():
last_count = 0
for i in range(100):
last = (yield from read_from_stream(dut.output, extract="last"))
last_count += last
if i % 10 == 1:
assert last
else:
assert not last
if i % 3 == 0:
yield from do_nothing()
self.assertEqual(last_count, 10)
def answer_write_burst(axi: AxiEndpoint, timeout=100):
memory = {}
addr, burst_len, burst_type, beat_size_bytes = yield from read_from_stream(
axi.write_address,
("payload", "burst_len", "burst_type", "beat_size_bytes"), timeout)
assert 2**beat_size_bytes == axi.data_bytes
assert burst_type == AxiBurstType.INCR.value
accepted = 0
for i in range(burst_len + 1):
value, last, byte_strobe = yield from read_from_stream(
axi.write_data, ("payload", "last", "byte_strobe"), timeout)
if i == burst_len:
assert last
else:
pass
assert not last
if byte_strobe != 0:
memory[addr + i * axi.data_bytes] = value
accepted += 1
write_to_stream(axi.write_response, resp=AxiResponse.OKAY)
print("wrote", memory)
return memory, accepted
def answer_read_burst(axi: AxiEndpoint, memory: Dict[int, int], timeout=100):
addr, burst_len, burst_type, beat_size_bytes = yield from read_from_stream(
axi.read_address,
("payload", "burst_len", "burst_type", "beat_size_bytes"), timeout)
assert 2**beat_size_bytes == axi.data_bytes
assert burst_type == AxiBurstType.INCR.value
print("read", addr, burst_len)
for i in range(burst_len + 1):
yield from write_to_stream(axi.read_data,
payload=memory[addr + (i * axi.data_bytes)],
resp=AxiResponse.OKAY,
last=(i == burst_len),
timeout=timeout)
def read_frame_from_stream(stream, timeout=100, pause=False):
random = Random(1)
frame = [[]]
while True:
if (random.random() < 0.3) and pause:
yield from do_nothing()
px, line_last, frame_last = (yield from read_from_stream(
stream,
timeout=timeout,
extract=("payload", "line_last", "frame_last")))
frame[-1].append(px)
if frame_last:
return frame
if line_last:
frame.append([])
def read_process():
read = []
while True:
payload, last = (yield from
read_from_stream(bit_stuffing.output,
extract=("payload", "last")))
read.append("{:08b}".format(payload))
if last:
break
read_bitarray = "".join(x[::-1] for x in read)
print(read_bitarray)
decode_iter = bitarray(read_bitarray).iterdecode(
{k: bitarray(v[::-1])
for k, v in huffman.table.items()})
for c, expected in zip(decode_iter, input_data):
self.assertEqual(chr(c), expected)
def read_process():
read = ""
while True:
data, length, last = (yield from read_from_stream(
huffman.output,
extract=("payload", "current_width", "last")))
bitstring = "{:0255b}".format(data)[::-1][:length]
read += bitstring
if last:
break
print(read)
decode_iter = bitarray(read).iterdecode(
{k: bitarray(v[::-1])
for k, v in huffman.table.items()})
decoded = ""
try:
for c in decode_iter:
decoded += chr(c)
except ValueError: # Decoding may not finish with the byte boundary
pass
self.assertEqual(input_data, decoded)
def reader():
for _ in range(100):
a = yield from read_from_stream(gear_12_to_64.output)
b = yield from read_from_stream(gear_48_to_64.output)
print(f"{a:064b}")
self.assertEqual(a, b)
def read_data_process():
read_result = []
while len(read_result) < len(golden_read_result):
read = yield from read_from_stream(dut.output)
read_result.append(read)
self.assertEqual(read_result, golden_read_result)
def reader():
for i, v in enumerate(output_data):
read = (yield from read_from_stream(fifo_out.output))
self.assertEqual(read, v)