def test_one_stream(self):
"""
Test the stream combiner with a single stream of data.
"""
width = 32
sendnth = 4
input_buffer_length = 64
max_packet_length = 1024
# First bit is 0 so data is from 0 to pow(2, 31)-1
maxint = pow(2, width-1)-1
n_data = 10
data = [self.rg.randint(0, maxint) for d in range(n_data)]
# How many steps are required to simulate the data.
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines(
{'N_STREAMS': 1,
'LOG_N_STREAMS': 1,
'WIDTH': width,
'INPUT_BUFFER_LENGTH': 16,
'LOG_INPUT_BUFFER_LENGTH': 4,
'MAX_PACKET_LENGTH': 16,
'LOG_MAX_PACKET_LENGTH': 4,
})
executable = buildutils.generate_icarus_executable(
'message', 'message_stream_combiner', '-one_stream', defines)
tb = TestBenchIcarusOuter(executable, in_raw=data, width=width,
output_msgs=False)
tb.run(steps_rqd)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_raw), len(data))
for r, e in zip(tb.out_raw, data):
self.assertEqual(e, r)
def test_one_stream(self):
"""
Test the stream combiner with a single stream of data.
"""
width = 32
sendnth = 4
input_buffer_length = 64
max_packet_length = 1024
# First bit is 0 so data is from 0 to pow(2, 31)-1
maxint = pow(2, width - 1) - 1
n_data = 10
data = [self.rg.randint(0, maxint) for d in range(n_data)]
# How many steps are required to simulate the data.
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines({
'N_STREAMS': 1,
'LOG_N_STREAMS': 1,
'WIDTH': width,
'INPUT_BUFFER_LENGTH': 16,
'LOG_INPUT_BUFFER_LENGTH': 4,
'MAX_PACKET_LENGTH': 16,
'LOG_MAX_PACKET_LENGTH': 4,
})
executable = buildutils.generate_icarus_executable(
'message', 'message_stream_combiner', '-one_stream', defines)
tb = TestBenchIcarusOuter(executable,
in_raw=data,
width=width,
output_msgs=False)
tb.run(steps_rqd)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_raw), len(data))
for r, e in zip(tb.out_raw, data):
self.assertEqual(e, r)
def test_one(self):
packet = [2159820100L, 878477756, pow(2, 23) + 1, 2, 3, 4]
packets = [packet] * 10
data = range(1, 100)
for packet in packets:
data.extend(packet)
data.extend(range(100, 110))
buffer_length = 128
defines = config.updated_defines({
'COMBINER_BUFFER_LENGTH':
buffer_length,
'LOG_COMBINER_BUFFER_LENGTH':
logceil(buffer_length),
'MAX_PACKET_LENGTH':
pow(2, config.msg_length_width),
})
executable = buildutils.generate_icarus_executable(
'message', 'message_stream_combiner_one', '-72', defines=defines)
fpgaimage = buildutils.generate_B100_image(
'message', 'message_stream_combiner_one', '-72', defines=defines)
tb_icarus = TestBenchIcarusOuter(executable, in_raw=data)
tb_b100 = TestBenchB100(fpgaimage, in_raw=data)
for tb, steps in (
(tb_icarus, 10000),
(tb_b100, 100000),
):
tb.run(steps)
self.assertEqual(len(data), len(tb.out_raw))
for e, r in zip(data, tb.out_raw):
self.assertEqual(e, r)
def test_slicer(self):
"""
Test the stream slicer.
"""
width = 32
n_slices = 3
sendnth = 4
buffer_length = 16
n_data = 10
data = []
expected_data = []
mfactor = pow(2, width)
for i in range(n_data):
m = pow(mfactor, n_slices - 1)
t = 0
for s in range(n_slices):
d = self.rg.randint(0, mfactor - 1)
t += d * m
m = m / mfactor
expected_data.append(d)
data.append(t)
# How many steps are required to simulate the data.
steps_rqd = len(data) * sendnth * 2 #+ 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines({
'N_SLICES':
3,
'LOG_N_SLICES':
logceil(n_slices),
'WIDTH':
width,
'BUFFER_LENGTH':
buffer_length,
'LOG_BUFFER_LENGTH':
logceil(buffer_length),
})
executable = buildutils.generate_icarus_executable(
'message', 'message_slicer', '-test', defines)
tb = TestBenchIcarusOuter(executable,
in_raw=data,
width=width,
output_msgs=False)
tb.run(steps_rqd)
# Now check output
self.assertEqual(len(expected_data), len(tb.out_raw))
for e, r in zip(expected_data, tb.out_raw):
self.assertAlmostEqual(e, r, 3)
def test_one(self):
"""
Test the buffer_AA and buffer_BB module.
"""
width = config.default_width
sendnth = 1
maxint = pow(2, width)-1
buffer_length = 32
n_data = 100
data = [random.randint(1, maxint) for d in range(n_data)]
# How many steps are required to simulate the data.
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines(
{'WIDTH': width,
'BUFFER_LENGTH': buffer_length,
'LOG_BUFFER_LENGTH': logceil(buffer_length),
'WRITEERRORCODE': 666,
'READERRORCODE': 777,
})
executableAA = buildutils.generate_icarus_executable(
'flow', 'buffer_AA', '-test', defines=defines)
fpgaimageAA = buildutils.generate_B100_image(
'flow', 'buffer_AA', '-test', defines=defines)
executableBB = buildutils.generate_icarus_executable(
'flow', 'buffer_BB', '-test', defines=defines)
fpgaimageBB = buildutils.generate_B100_image(
'flow', 'buffer_BB', '-test', defines=defines)
tb_icarusAA = TestBenchIcarusOuter(executableAA, in_raw=data,
output_msgs=False)
tb_b100AA = TestBenchB100(fpgaimageAA, in_raw=data, output_msgs=False)
tb_icarusBB = TestBenchIcarusOuter(executableBB, in_raw=data,
output_msgs=False)
tb_b100BB = TestBenchB100(fpgaimageBB, in_raw=data, output_msgs=False)
for tb, steps in (
(tb_icarusAA, steps_rqd),
(tb_b100AA, 100000),
(tb_icarusBB, steps_rqd),
(tb_b100BB, 100000),
):
tb.run(steps)
# Confirm that our data is correct.
stream = None
self.assertEqual(len(tb.out_raw), len(data))
for r, e in zip(tb.out_raw, data):
self.assertEqual(e, r)
def test_combo(self):
"""
Tests sample msg splitter and message stream combiner together.
"""
top_packet_length = 64
n_packets = 20
width = 32
prob_start = 0.1
data, packets = msg_utils.generate_random_packets(
top_packet_length,
n_packets,
config.msg_length_width,
width,
prob_start,
self.rg,
none_sample=False)
padded_data = data
buffer_length = 128
defines = config.updated_defines({
'COMBINER_BUFFER_LENGTH':
buffer_length,
'LOG_COMBINER_BUFFER_LENGTH':
logceil(buffer_length),
'MAX_PACKET_LENGTH':
pow(2, config.msg_length_width),
})
executable = buildutils.generate_icarus_executable('message',
'combo',
'-test',
defines=defines)
fpgaimage = buildutils.generate_B100_image('message',
'combo',
'-test',
defines=defines)
tb_icarus = TestBenchIcarusOuter(executable, in_raw=data)
tb_b100 = TestBenchB100(fpgaimage, in_raw=padded_data)
for tb, steps in (
(tb_icarus, 10000),
(tb_b100, 100000),
):
tb.run(steps)
e_samples, e_packets = msg_utils.stream_to_samples_and_packets(
data, config.msg_length_width, width)
r_samples, r_packets = msg_utils.stream_to_samples_and_packets(
tb.out_raw, config.msg_length_width, width)
# Confirm all the samples are equal.
self.assertEqual(len(e_samples), len(r_samples))
for e, r in zip(e_samples, r_samples):
self.assertEqual(e, r)
# Confirm all the packets are equal.
self.assertEqual(len(e_packets), len(r_packets))
for ep, rp in zip(e_packets, r_packets):
self.assertEqual(len(ep), len(rp))
for e, r in zip(ep, rp):
self.assertEqual(e, r)
def test_one(self):
"""
Test the multiply_complex module.
"""
sendnth = 2
n_data = 1000
in_samples = []
expected = []
xs = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
ys = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
for x, y in zip(xs, ys):
in_samples.append(x)
in_samples.append(y)
z = x * y / 2
# We divide by two since multiplying two complex numbers in range (-1,-1) to (1,1)
# produces a result in range (-2, -2) to (2, 2).
expected.append(z)
steps_rqd = len(in_samples) * sendnth * 2 + 100
executable_inner = buildutils.generate_icarus_executable(
'fpgamath',
'multiply_complex_inner',
'-test',
)
executable_outer = buildutils.generate_icarus_executable(
'fpgamath',
'multiply_complex',
'-test',
)
fpgaimage = buildutils.generate_B100_image('fpgamath',
'multiply_complex', '-test')
tb_icarus_inner = TestBenchIcarusInner(executable_inner,
in_samples,
sendnth=sendnth)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer,
in_samples,
sendnth=sendnth)
tb_b100 = TestBenchB100(fpgaimage, in_samples)
for tb, steps, check_ms in (
(tb_icarus_inner, steps_rqd, True),
(tb_icarus_outer, steps_rqd, False),
(tb_b100, 100000, False),
):
tb.run(steps)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_samples), len(expected))
for r, e in zip(tb.out_samples, expected):
self.assertAlmostEqual(e, r, 3)
def test_slicer(self):
"""
Test the stream slicer.
"""
width = 32
n_slices = 3
sendnth = 4
buffer_length = 16
n_data = 10
data = []
expected_data = []
mfactor = pow(2, width)
for i in range(n_data):
m = pow(mfactor, n_slices-1)
t = 0
for s in range(n_slices):
d = self.rg.randint(0, mfactor-1)
t += d * m
m = m / mfactor
expected_data.append(d)
data.append(t)
# How many steps are required to simulate the data.
steps_rqd = len(data) * sendnth * 2 #+ 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines(
{'N_SLICES': 3,
'LOG_N_SLICES': logceil(n_slices),
'WIDTH': width,
'BUFFER_LENGTH': buffer_length,
'LOG_BUFFER_LENGTH': logceil(buffer_length),
})
executable = buildutils.generate_icarus_executable(
'message', 'message_slicer', '-test', defines)
tb = TestBenchIcarusOuter(executable, in_raw=data, width=width,
output_msgs=False)
tb.run(steps_rqd)
# Now check output
self.assertEqual(len(expected_data), len(tb.out_raw))
for e,r in zip(expected_data, tb.out_raw):
self.assertAlmostEqual(e, r, 3)
def test_one(self):
"""
Test the split module.
"""
width = 32
sendnth = 4
maxint = pow(2, width)-1
n_data = 100
n_streams = 3
data = [random.randint(0, maxint) for d in range(n_data)]
# Work out what the expected result is.
expected_data = []
for ds in [data[n_streams*i:n_streams*(i+1)] for i in range(n_data/n_streams)]:
e_d = 0
f = 1
for d in ds:
e_d += d*f
f *= pow(2, width)
expected_data.append(e_d)
# How many steps are required to simulate the data.
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines(
{'N_OUT_STREAMS': n_streams,
'LOG_N_OUT_STREAMS': logceil(n_streams),
'WIDTH': width,
})
executable = buildutils.generate_icarus_executable(
'flow', 'split', '-test', defines)
tb = TestBenchIcarusOuter(executable, in_raw=data, width=width,
output_msgs=False)
tb.run(steps_rqd)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_raw), len(expected_data))
for r, e in zip(tb.out_raw, expected_data):
self.assertEqual(e, r)
def test_return_one(self):
"""
Test the split module.
"""
width = config.default_width
sendnth = 4
maxint = pow(2, width)-1
n_data = 100
n_streams = 2
data = [random.randint(0, maxint) for d in range(n_data)]
# Work out what the expected result is.
# We don't know which stream will be returned.
expected_data = data[::2]
alt_expected_data = data[1::2]
# How many steps are required to simulate the data.
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines(
{'WIDTH': width,
})
executable = buildutils.generate_icarus_executable(
'flow', 'split_return_one', '-test', defines=defines)
fpgaimage = buildutils.generate_B100_image(
'flow', 'split_return_one', '-test', defines=defines)
tb_icarus = TestBenchIcarusOuter(executable, in_raw=data,
output_msgs=False)
tb_b100 = TestBenchB100(fpgaimage, in_raw=data, output_msgs=False)
for tb, steps in (
(tb_icarus, steps_rqd),
(tb_b100, 100000),
):
tb.run(steps)
# Confirm that our data is correct.
stream = None
self.assertEqual(len(tb.out_raw), len(expected_data))
for r, e, a in zip(tb.out_raw, expected_data, alt_expected_data):
if stream is None:
if (r != e):
stream = 2
else:
stream = 1
if stream == 1:
self.assertEqual(e, r)
else:
self.assertEqual(a, r)
def test_one(self):
"""
Test the multiply module.
"""
sendnth = 2
n_data = 1000
in_samples = []
expected = []
# We send samples a + bj and expected returned 0 + abj.
in_samples = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
expected = [c.real * c.imag * 1j for c in in_samples]
steps_rqd = len(in_samples) * sendnth * 2 + 100
executable_inner = buildutils.generate_icarus_executable(
'fpgamath',
'multiply_inner',
'-test',
)
executable_outer = buildutils.generate_icarus_executable(
'fpgamath',
'multiply',
'-test',
)
fpgaimage = buildutils.generate_B100_image('fpgamath', 'multiply',
'-test')
tb_icarus_inner = TestBenchIcarusInner(executable_inner,
in_samples,
sendnth=sendnth)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer,
in_samples,
sendnth=sendnth)
tb_b100 = TestBenchB100(fpgaimage, in_samples)
for tb, steps, check_ms in (
(tb_icarus_inner, steps_rqd, True),
(tb_icarus_outer, steps_rqd, False),
(tb_b100, 100000, False),
):
tb.run(steps)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_samples), len(expected))
for r, e in zip(tb.out_samples, expected):
self.assertAlmostEqual(e, r, 3)
def atest_null(self):
"""
Tests the null qa_wrapper.
"""
width = 32
max_sample = pow(2, width - 2) - 1
n_samples = 10
data = [self.rg.randint(0, max_sample) for i in range(n_samples)]
executable = buildutils.generate_icarus_executable(
'uhd', 'null', '-test')
fpgaimage = buildutils.generate_B100_image('uhd', 'null', '-test')
tb_icarus = TestBenchIcarusOuter(executable, in_raw=data)
tb_b100 = TestBenchB100(fpgaimage, in_raw=data)
for tb, steps in (
(tb_icarus, 5000),
(tb_b100, 10000),
):
tb.run(steps)
self.assertEqual(len(data), len(tb.out_raw))
for e, r in zip(data, tb.out_raw):
self.assertEqual(e, r)
def test_one(self):
"""
Tests passing debug messages back.
"""
width = 32
sendnth = 2
max_val = pow(2, width - 2) - 1
n_data = 10
in_data = [random.randint(1, max_val) for i in range(n_data)]
defines = config.updated_defines({})
executable = buildutils.generate_icarus_executable('message',
'debug',
'-test',
defines=defines)
fpgaimage = buildutils.generate_B100_image('message',
'debug',
'-test',
defines=defines)
tb_icarus = TestBenchIcarusOuter(executable,
in_raw=in_data,
sendnth=sendnth)
tb_b100 = TestBenchB100(fpgaimage, in_raw=in_data)
for tb, steps in (
#(tb_icarus, len(in_data)*sendnth*2+1000),
(tb_b100, 100000), ):
tb.run(steps)
r_samples, r_packets = msg_utils.stream_to_samples_and_packets(
tb.out_raw, config.msg_length_width, width)
print(in_data)
print(r_samples)
print(r_packets)
self.assertEqual(len(in_data), len(r_samples))
for e, r in zip(in_data, r_samples):
self.assertEqual(e, r)
e_even = [s for s in in_data if s % 2 == 0]
r_even = [p[1] for p in r_packets]
self.assertEqual(len(e_even), len(r_even))
for e, r in zip(e_even, r_even):
self.assertEqual(e, r)
def test_sample_msg_splitter_returns_msgs(self):
"""
Tests the sample msg splitter.
Just checks that the messages are correct.
"""
# Then test qa_wrapper modules returning the messages.
executable = buildutils.generate_icarus_executable(
'message', 'sample_msg_splitter_returns_msgs', '-test')
fpgaimage = buildutils.generate_B100_image(
'message', 'sample_msg_splitter_returns_msgs', '-test')
tb_icarus = TestBenchIcarusOuter(executable, in_raw=self.data)
tb_b100 = TestBenchB100(fpgaimage, in_raw=self.data)
for tb, steps in (
(tb_icarus, 10000),
(tb_b100, 1000),
):
tb.run(steps)
samples, packets = msg_utils.stream_to_samples_and_packets(
tb.out_raw, config.msg_length_width, self.width)
self.assertEqual(len(samples), 0)
first_index = None
for i, p in enumerate(packets):
if p != self.dummypacket:
first_index = i
break
last_index = None
for i, p in reversed(list(enumerate(packets))):
if p != self.dummypacket:
last_index = i + 1
break
if first_index is None:
raise StandardError("No packets found")
packets = packets[first_index:last_index]
self.assertEqual(len(packets), len(self.packets))
for e, r in zip(packets, self.packets):
self.assertEqual(len(e), len(r))
for ee, rr in zip(e, r):
self.assertEqual(ee, rr)
def test_sample_msg_splitter(self):
"""
Tests the sample msg splitter.
Just checks that the samples are correct.
"""
# First test qa_wrapper modules that return the samples
executable = buildutils.generate_icarus_executable(
'message', 'sample_msg_splitter', '-test')
fpgaimage = buildutils.generate_B100_image('message',
'sample_msg_splitter',
'-test')
tb_icarus = TestBenchIcarusOuter(executable, in_raw=self.data)
tb_b100 = TestBenchB100(fpgaimage, in_raw=self.data)
for tb, steps in (
(tb_icarus, 10000),
(tb_b100, 10000),
):
tb.run(steps)
samples, packets = msg_utils.stream_to_samples_and_packets(
self.original_data, config.msg_length_width, self.width)
self.assertEqual(len(samples), len(tb.out_raw))
for e, r in zip(samples, tb.out_raw):
self.assertEqual(e, r)
def test_bits(self):
width = 32
maxint = pow(2, width) - 1
n_data = 10
data = [random.randint(1, maxint) for d in range(n_data)]
buffer_length = 128
defines = config.updated_defines({
'COMBINER_BUFFER_LENGTH':
buffer_length,
'LOG_COMBINER_BUFFER_LENGTH':
logceil(buffer_length),
'MAX_PACKET_LENGTH':
pow(2, config.msg_length_width),
'WIDTH':
width,
'LOG_SENDNTH':
14,
'LOG_WIDTH':
logceil(width),
'ERRORCODE':
666,
})
executable = buildutils.generate_icarus_executable(
'message',
'message_stream_combiner_bits',
'-test',
defines=defines)
fpgaimage = buildutils.generate_B100_image(
'message',
'message_stream_combiner_bits',
'-test',
defines=defines)
tb_icarus = TestBenchIcarusOuter(executable, in_raw=data, sendnth=70)
tb_b100 = TestBenchB100(fpgaimage, in_raw=data)
for tb, steps in (
(tb_icarus, 10000),
(tb_b100, 100000),
):
tb.run(steps)
start_pos = None
for i, x in enumerate(tb.out_raw):
if (x == width - 1):
start_pos = i
break
for i, x in reversed(zip(range(0, len(tb.out_raw)), tb.out_raw)):
if (x == width - 1):
stop_pos = i
break
if start_pos is None:
raise ValueError("{0} not found in output".format(width - 1))
out = tb.out_raw[start_pos:stop_pos + 2 * width]
bitted = [
out[i * 2 * width + 1:(i + 1) * 2 * width + 1:2]
for i in range(len(out) / width / 2)
]
poses = [
out[i * 2 * width:(i + 1) * 2 * width:2]
for i in range(len(out) / width / 2)
]
expected = [31 - x for x in range(32)]
for i, p in enumerate(poses):
self.assertEqual(p, expected)
r_ints = [bits_to_int(bits) for bits in bitted]
r_ints = [x for x in r_ints if x != 0]
self.assertEqual(len(data), len(r_ints))
for e, r in zip(data, r_ints):
self.assertEqual(e, r)
def test_one(self):
"""
Test the stage module.
"""
width = config.default_width
sendnth = config.default_sendnth
# Changing N will require resynthesis.
N = 8
# Arguments used for producing verilog from templates.
extraargs = {}
# Amount of data to send.
n_data = 2 * N
# Define the input
in_samples = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
steps_rqd = len(in_samples) * sendnth + 100
# Define meta data
mwidth = 3
in_ms = [random.randint(0, pow(2, mwidth) - 1) for d in in_samples]
expected = in_samples
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
defines = config.updated_defines({
'WIDTH': width,
'MWIDTH': mwidth,
'N': N
})
executable_inner = buildutils.generate_icarus_executable(
'fft',
'stage_inner',
'-{0}'.format(N),
defines=defines,
extraargs=extraargs)
executable_outer = buildutils.generate_icarus_executable(
'fft',
'stage',
'-{0}'.format(N),
defines=defines,
extraargs=extraargs)
#fpgaimage = buildutils.generate_B100_image(
# 'fft', 'stage', '-{0}'.format(N), defines=defines,
# extraargs=extraargs)
tb_icarus_inner = TestBenchIcarusInner(executable_inner, in_samples,
in_ms)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer, in_samples)
#tb_b100 = TestBenchB100(fpgaimage, in_samples)
for tb, steps, check_ms in (
(tb_icarus_inner, steps_rqd, True),
(tb_icarus_outer, steps_rqd, False),
#(tb_b100, 100000, False),
):
tb.run(steps)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_samples), len(expected))
for r, e in zip(tb.out_samples, expected):
self.assertAlmostEqual(e, r, 3)
if check_ms:
self.assertEqual(len(tb.out_ms), len(in_ms))
for r, e in zip(tb.out_ms, in_ms):
self.assertEqual(e, r)
def test_one(self):
"""
Tests split module and message stream combiner together.
"""
width = 32
sendnth = 2
max_packet_length = 10
n_packets = 20
data1 = []
for i in range(n_packets):
length = random.randint(0, max_packet_length)
packet = msg_utils.generate_random_packet(length,
config.msg_length_width,
width)
data1.extend(packet)
max_val = pow(2, width - 1) - 1
data2 = [random.randint(1, max_val) for i in range(len(data1))]
i_data = []
for d1, d2 in zip(data1, data2):
i_data.append(d1)
i_data.append(d2)
a_data = data1 + data2
padded_data = i_data + [0] * 1000
buffer_length = 128
defines = config.updated_defines({
'COMBINER_BUFFER_LENGTH':
buffer_length,
'LOG_COMBINER_BUFFER_LENGTH':
logceil(buffer_length),
'MAX_PACKET_LENGTH':
pow(2, config.msg_length_width),
'ERRORCODE':
666,
'WIDTH':
width,
})
executable = buildutils.generate_icarus_executable('message',
'splitcombiner',
'-test',
defines=defines)
fpgaimage = buildutils.generate_B100_image('message',
'splitcombiner',
'-test',
defines=defines)
tb_icarus = TestBenchIcarusOuter(executable,
in_raw=i_data,
sendnth=sendnth)
tb_b100 = TestBenchB100(fpgaimage, in_raw=padded_data)
for tb, steps in (
(tb_icarus, len(i_data) * sendnth * 2 + 1000),
(tb_b100, 100000),
):
tb.run(steps)
e_samples, e_packets = msg_utils.stream_to_samples_and_packets(
a_data, config.msg_length_width, width)
r_samples, r_packets = msg_utils.stream_to_samples_and_packets(
tb.out_raw, config.msg_length_width, width)
# Remove 0's from samples.
# The splitter can introduce 0's at beginning and end.
r_samples = [r for r in r_samples if r != 0]
self.assertEqual(len(e_samples), len(r_samples))
for e, r in zip(e_samples, r_samples):
self.assertEqual(e, r)
# Confirm all the packets are equal.
self.assertEqual(len(e_packets), len(r_packets))
for ep, rp in zip(e_packets, r_packets):
self.assertEqual(len(ep), len(rp))
for e, r in zip(ep, rp):
self.assertEqual(e, r)
def test_one(self):
"""
Test the butterfly module.
"""
sendnth = 5
n_data = 1
width = 32
in_samples = []
expected = []
xas = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
xbs = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
# Max val of w is 10000 (roughly 0.5)
ws = [
0.5 * (random.random() * 2 - 1) + 0.5 * (random.random() * 2j - 1j)
for i in range(n_data)
]
for xa, xb, w in zip(xas, xbs, ws):
in_samples.append(xa)
in_samples.append(xb)
in_samples.append(w)
ya = xa + xb * w
yb = xa - xb * w
expected.append(ya / 2)
expected.append(yb / 2)
steps_rqd = len(in_samples) * sendnth * 2 + 100
# Define meta data
mwidth = 1
raw_ms = [random.randint(0, pow(2, mwidth) - 1) for i in range(n_data)]
in_ms = []
expected_ms = []
for m in raw_ms:
in_ms.extend((m, 0, 0))
expected_ms.extend((m, 0))
defines = config.updated_defines({
'DEBUG': True,
})
executable_inner = buildutils.generate_icarus_executable(
'fft', 'butterfly_inner', '-test', defines=defines)
executable_outer = buildutils.generate_icarus_executable(
'fft', 'butterfly', '-test', defines=defines)
#fpgaimage = buildutils.generate_B100_image(
# 'fft', 'butterfly', '-test', defines=defines)
tb_icarus_inner = TestBenchIcarusInner(executable_inner,
in_samples,
in_ms,
sendnth=sendnth)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer,
in_samples,
sendnth=sendnth)
#tb_b100 = TestBenchB100(fpgaimage, in_samples)
for tb, steps, check_ms in (
(tb_icarus_inner, steps_rqd, True),
(tb_icarus_outer, steps_rqd, False),
#(tb_b100, 100000, False),
):
tb.run(steps)
# Confirm that our data is correct.
print(tb.out_raw)
print(tb.out_samples)
print(expected)
self.assertEqual(len(tb.out_samples), len(expected))
for msg in tb.out_messages:
print("message is")
print(msg)
xa = int_to_c(msg[1], width / 2 - 1)
xbw = int_to_c(msg[2], width / 2 - 1)
ya = int_to_c(msg[3], width / 2 - 1)
yb = int_to_c(msg[4], width / 2 - 1)
print("e xa is {0} xbw is {1}".format(xas[0] / 2,
xbs[0] * ws[0] / 2))
print("r xa is {0} xbw is {1}".format(xa, xbw))
for r, e in zip(tb.out_samples, expected):
print(e, r)
self.assertAlmostEqual(e, r, 3)
if check_ms:
self.assertEqual(len(tb.out_ms), len(expected_ms))
for r, e in zip(tb.out_ms, expected_ms):
self.assertEqual(e, r)
def test_one(self):
"""
Test the filterbank module.
"""
width = config.default_width
sendnth = config.default_sendnth
# Changing filter_length will require resynthesis.
n_filters = 3
filter_length = 3
all_taps = []
combined_taps = []
for n in range(n_filters):
taps = [random.random() * 2 - 1 for i in range(filter_length)]
total = sum([abs(t) for t in taps])
taps = [t / total for t in taps]
all_taps.append(taps)
combined_taps.extend(taps)
# Arguments used for producing verilog from templates.
extraargs = {
'summult_length': filter_length,
}
# Amount of data to send.
n_data = 30
# Define the input
in_samples = [0] * filter_length * n_filters * 2
in_samples += [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
in_samples += [0] * (filter_length - 1) * n_filters
steps_rqd = len(in_samples) * sendnth + 100
# Define meta data
mwidth = 1
in_ms = [random.randint(0, pow(2, mwidth) - 1) for d in in_samples]
possible_expected = []
for m in range(n_filters):
shifted_taps = all_taps[m:] + all_taps[:m]
expected_outputs = []
for n in range(n_filters):
filter_inputs = in_samples[n::n_filters]
convolved = convolve(filter_inputs, shifted_taps[n])
expected_outputs.append(convolved)
expected = []
for eo in zip(*expected_outputs):
expected.extend(eo)
possible_expected.append(expected)
steps_rqd = n_data * sendnth * 2 + 1000
# Create, setup and simulate the test bench.
filter_id = 123
defines = config.updated_defines({
'WIDTH': width,
'FILTER_LENGTH': filter_length,
'FILTERBANK_ID': filter_id,
'N_FILTERS': n_filters,
'FILTERBANK_MSG_BUFFER_LENGTH': 128,
})
executable_inner = buildutils.generate_icarus_executable(
'flter',
'filterbank_inner',
'-test',
defines=defines,
extraargs=extraargs)
executable_outer = buildutils.generate_icarus_executable(
'flter',
'filterbank',
'-test',
defines=defines,
extraargs=extraargs)
fpgaimage = buildutils.generate_B100_image('flter',
'filterbank',
'-test',
defines=defines,
extraargs=extraargs)
start_msgs = taps_to_start_msgs(combined_taps, defines['WIDTH'] / 2,
filter_id)
tb_icarus_inner = TestBenchIcarusInner(executable_inner, in_samples,
in_ms, start_msgs)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer, in_samples,
start_msgs)
tb_b100 = TestBenchB100(fpgaimage, in_samples, start_msgs)
for tb, steps in (
(tb_icarus_inner, steps_rqd),
(tb_icarus_outer, steps_rqd),
(tb_b100, 100000),
):
tb.run(steps)
# Confirm that our data is correct.
received = prune_zeros(tb.out_samples)
tol = 0.001
matched_once = False
for expected in possible_expected:
expected = prune_zeros(expected)
matches = True
if (len(received) != len(expected)):
matches = False
else:
for r, e in zip(received, expected):
if (abs(r - e) > tol):
matches = False
break
if matches:
matched_once = True
self.assertTrue(matched_once)
def test_bits(self):
"""
Tests the bits qa_wrapper.
"""
width = 32
sendnth = 70
max_sample = pow(2, width) - 1
n_samples = 2
data = [self.rg.randint(1, max_sample) for i in range(n_samples)]
defines = config.updated_defines({
'LOG_WIDTH': logceil(width),
'ERRORCODE': 666,
'WIDTH': width,
'LOG_SENDNTH': 12,
})
executable = buildutils.generate_icarus_executable('uhd',
'bits',
'-test',
defines=defines)
fpgaimage = buildutils.generate_B100_image('uhd',
'bits',
'-test',
defines=defines)
tb_icarus = TestBenchIcarusOuter(executable,
in_raw=data,
sendnth=sendnth)
tb_b100 = TestBenchB100(fpgaimage, in_raw=data)
for tb, steps in (
(tb_icarus, 5000),
(tb_b100, 100000),
):
tb.run(steps)
start_pos = None
for i, x in enumerate(tb.out_raw):
if (x == width - 1):
start_pos = i
break
for i, x in reversed(zip(range(0, len(tb.out_raw)), tb.out_raw)):
if (x == width - 1):
stop_pos = i
break
if start_pos is None:
raise ValueError("{0} not found in output".format(width - 1))
out = tb.out_raw[start_pos:stop_pos + 2 * width]
bitted = [
out[i * 2 * width + 1:(i + 1) * 2 * width + 1:2]
for i in range(len(out) / width / 2)
]
poses = [
out[i * 2 * width:(i + 1) * 2 * width:2]
for i in range(len(out) / width / 2)
]
expected = [31 - x for x in range(32)]
for i, p in enumerate(poses):
if (p != expected):
print(i)
print(p)
self.assertEqual(p, expected)
r_ints = [bits_to_int(bits) for bits in bitted]
r_ints = [x for x in r_ints if x != 0]
self.assertEqual(len(data), len(r_ints))
for e, r in zip(data, r_ints):
self.assertEqual(e, r)
def test_one(self):
"""
Test the filter module.
"""
width = config.default_width
sendnth = config.default_sendnth
# Changing filter_length will require resynthesis.
filter_length = 4
taps = [random.random() * 2 - 1 for i in range(filter_length)]
total = sum([abs(t) for t in taps])
taps = [t / total for t in taps]
# Arguments used for producing verilog from templates.
extraargs = {
'summult_length': filter_length,
}
# Amount of data to send.
n_data = 10
# Define the input
in_samples = [
random.random() * 2 - 1 + random.random() * 2j - 1j
for i in range(n_data)
]
in_samples += [0] * (filter_length - 1)
steps_rqd = len(in_samples) * sendnth + 100
# Define meta data
mwidth = 1
in_ms = [random.randint(0, pow(2, mwidth) - 1) for d in in_samples]
expected = convolve(in_samples, taps)
steps_rqd = n_data * sendnth * 2 + 1000
filter_id = 123
# Create, setup and simulate the test bench.
defines = config.updated_defines({
'WIDTH': width,
'FILTER_LENGTH': filter_length,
'FILTER_ID': filter_id,
})
executable_inner = buildutils.generate_icarus_executable(
'flter',
'filter_inner',
'-test',
defines=defines,
extraargs=extraargs)
executable_outer = buildutils.generate_icarus_executable(
'flter', 'filter', '-test', defines=defines, extraargs=extraargs)
fpgaimage = buildutils.generate_B100_image('flter',
'filter',
'-test',
defines=defines,
extraargs=extraargs)
start_msgs = taps_to_start_msgs(taps, defines['WIDTH'] / 2, filter_id)
tb_icarus_inner = TestBenchIcarusInner(executable_inner, in_samples,
in_ms, start_msgs)
tb_icarus_outer = TestBenchIcarusOuter(executable_outer, in_samples,
start_msgs)
tb_b100 = TestBenchB100(fpgaimage, in_samples, start_msgs)
for tb, steps in (
(tb_icarus_inner, steps_rqd),
(tb_icarus_outer, steps_rqd),
(tb_b100, 100000),
):
tb.run(steps)
# Confirm that our data is correct.
self.assertEqual(len(tb.out_samples), len(expected))
for r, e in zip(tb.out_samples, expected):
self.assertAlmostEqual(e, r, 3)