def test_main(width_i, stages):
core = TreeAdderSigned(width_i=width_i,
n_stages=stages,
reg_in=True, reg_out=True)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_adder_i{width_i}_s{stages}.vcd')
run(core, 'cnn.tests.test_tree_operations', ports=ports, vcd_file=vcd_file)
def test_ej7(width_in, width_gain, width_out):
from ej7 import SumaPonderada
core = SumaPonderada()
ports = [
core.PiX0, core.PiX1, core.PiX2, core.PiW0, core.PiW1, core.PiW2,
core.PoZ
]
run(core, 'tb_ej7', ports=ports, vcd_file=waveform_dir + '/ej7.vcd')
def test_core(width, depth):
core = CircularROM(width=width, init=mem_init[:depth])
os.environ['cocotb_param_depth'] = str(depth)
ports = core.get_ports()
run(core,
'cnn.tests.test_rom',
ports=ports,
vcd_file=f'./test_rom_w{width}_d{depth}.vcd')
def test_axi_lite_device():
core = AxiLiteDevice(addr_w=5, data_w=32, registers=regs)
ports = [core.axi_lite[f] for f in core.axi_lite.fields]
ports += [core.registers[f] for f in core.registers.fields]
run(core,
'cores_nmigen.test.test_axi_lite',
ports=ports,
vcd_file='./test_axi_lite_device.vcd')
def test_dot_product(width_i, shape):
os.environ['coco_param_shape'] = str(shape)
core = DotProduct(width_i=width_i, shape=shape)
ports = core.get_ports()
printable_shape = '_'.join([str(i) for i in shape])
vcd_file = vcd_only_if_env(
f'./test_dot_product_i{width_i}_shape{printable_shape}.vcd')
run(core, 'cnn.tests.test_dot_product', ports=ports, vcd_file=vcd_file)
def test_main_wrapper(latency):
core = StreamWrapper(wrapped_core=ExampleCore(16, latency),
input_stream=DataStream(16, direction='sink', name='input'),
output_stream=DataStream(16, direction='source', name='output'),
input_map={'data': 'data_i'},
output_map={'data': 'data_o'},
latency=latency)
ports = core.get_ports()
run(core, 'cnn.tests.test_stream_wrapper', ports=ports, vcd_file=f'./test_stream_wrapper.vcd')
def test_main(width, depth):
fifo = StreamFifoCDC(input_stream=DataStream(width, 'sink', name='input'),
output_stream=DataStream(width, 'source', name='output'),
depth=depth,
r_domain='read',
w_domain='write')
ports = [fifo.input[f] for f in fifo.input.fields]
ports += [fifo.output[f] for f in fifo.output.fields]
run(fifo, 'cores_nmigen.test.test_fifo_cdc', ports=ports, vcd_file='test_stream_fifo_cdc.vcd')
def test_matrix_interface(width, shape):
os.environ['coco_param_shape'] = str(shape)
core = MatrixInterfaceBypass(width=width,
shape=shape
)
ports = core.get_ports()
printable_shape = '_'.join([str(i) for i in shape])
vcd_file = f'./test_matrix_interface_i{width}_shape{printable_shape}.vcd'
run(core, 'cores_nmigen.test.test_matrix_interface', ports=ports, vcd_file=vcd_file)
def test_farm(width, shape, n_cores):
os.environ['coco_param_shape'] = str(shape)
core = Farm(width=width,
shape=shape,
n_cores=n_cores)
ports = core.get_ports()
printable_shape = '_'.join([str(i) for i in shape])
vcd_file = vcd_only_if_env(f'./test_farm_i{width}_shape{printable_shape}.vcd')
run(core, 'cnn.tests.test_farm', ports=ports, vcd_file=vcd_file)
def test_main(width_i, n_stages, reg_in, reg_out):
core = TreeHighestUnsignedWrapped(width_i=width_i,
n_stages=n_stages,
reg_in=reg_in,
reg_out=reg_out)
N = len(core.inputs)
os.environ['coco_param_N'] = str(N)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_highest_w{width_i}_s{n_stages}.vcd')
run(core, 'cnn.tests.test_highest', ports=ports, vcd_file=vcd_file)
def test_main(data_w, height, width, N, mode):
os.environ['coco_param_height'] = str(height)
os.environ['coco_param_width'] = str(width)
os.environ['coco_param_N'] = str(N)
os.environ['coco_param_mode'] = mode
core = Pooling(data_w=data_w, input_shape=(height, width), N=N, mode=mode)
ports = core.get_ports()
vcd_file = vcd_only_if_env(
f'./test_pooling_dw{data_w}_h{height}_w{width}_N{N}_m{mode}.vcd')
run(core, 'cnn.tests.test_pooling', ports=ports, vcd_file=vcd_file)
def test_stream_macc(args, kwargs):
core = StreamMacc(*args, **kwargs)
ports = core.get_ports()
iw = len(core.input.data)
cw = len(core.r_data)
aw = len(core.accumulator)
ow = len(core.output.data)
vcd_file = vcd_only_if_env(
f'./test_stream_macc_i{iw}_c{cw}_a{aw}_w{ow}.vcd')
run(core, 'cnn.tests.test_stream_macc', ports=ports, vcd_file=vcd_file)
def test_row_fifos(input_w, row_length, N, invert):
os.environ['coco_param_N'] = str(N)
os.environ['coco_param_row_length'] = str(row_length)
os.environ['coco_param_invert'] = str(int(invert))
core = RowFifos(input_w=input_w, row_length=row_length, N=N, invert=invert)
vcd_file = vcd_only_if_env(
f'./test_row_fifos_i{input_w}_rowlength{row_length}_N{N}_invert{int(invert)}.vcd'
)
ports = core.get_ports()
run(core, 'cnn.tests.test_row_fifos', ports=ports, vcd_file=vcd_file)
def test_matrix_feeder(data_w, height, width, N, invert):
os.environ['coco_param_N'] = str(N)
os.environ['coco_param_height'] = str(height)
os.environ['coco_param_width'] = str(width)
os.environ['coco_param_invert'] = str(int(invert))
core = MatrixFeeder(data_w=data_w,
input_shape=(height, width),
N=N,
invert=invert)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_matrix_feeder_i{data_w}_h{height}_w{width}_N{N}_invert{invert}.vcd')
run(core, 'cnn.tests.test_matrix_feeder', ports=ports, vcd_file=vcd_file)
def test_convolution(width, img_height, img_width, N, n_cores):
os.environ['coco_param_N'] = str(N)
os.environ['coco_param_img_height'] = str(img_height)
os.environ['coco_param_img_width'] = str(img_width)
os.environ['coco_param_n_cores'] = str(int(n_cores))
core = Convolution(width=width,
input_shape=(img_height, img_width),
N=N,
n_cores=n_cores)
ports = core.get_ports()
vcd_file = vcd_only_if_env(
f'./test_convolution_i{width}_h{img_height}_w{img_width}_N{N}_n{n_cores}.vcd'
)
run(core, 'cnn.tests.test_convolution', ports=ports, vcd_file=vcd_file)
def test_mlp_node(width_i, width_w, n_inputs, n_neurons):
seed = random.randint(0, 99999)
os.environ['coco_param_n_inputs'] = str(n_inputs)
os.environ['coco_param_n_neurons'] = str(n_neurons)
os.environ['coco_param_seed'] = str(
seed) # so from cocotb can generate same random data
rom_init = get_rom(width_w, (n_inputs + 1) * n_neurons, seed=seed)
core = mlpNode(width_i=width_i,
width_w=width_w,
n_inputs=n_inputs,
rom_init=rom_init)
ports = core.get_ports()
vcd_file = vcd_only_if_env(
f'./test_mlp_node_d{width_i}_w{width_w}_n{n_inputs}_m{n_neurons}.vcd')
run(core, 'cnn.tests.test_mlp_node', ports=ports, vcd_file=vcd_file)
def test_main(data_w, input_shape, output_shape, fill_value):
ih, iw = input_shape
oh, ow = output_shape
os.environ['coco_param_ih'] = str(ih)
os.environ['coco_param_iw'] = str(iw)
os.environ['coco_param_oh'] = str(oh)
os.environ['coco_param_ow'] = str(ow)
os.environ['coco_param_fill_value'] = str(fill_value)
core = Resizer(data_w=data_w,
input_shape=input_shape,
output_shape=output_shape,
fill_value=fill_value)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_resizer_ih{ih}_iw{iw}_oh{oh}_ow{ow}_fill{fill_value}.vcd')
run(core, 'cnn.tests.test_resizer', ports=ports, vcd_file=vcd_file)
dut.rst <= 1
await RisingEdge(dut.clk)
await RisingEdge(dut.clk)
dut.rst <= 0
@cocotb.test()
async def burst(dut):
await init_test(dut)
stream_input = Stream.Driver(dut.clk, dut, 'a__')
stream_output = Stream.Driver(dut.clk, dut, 'r__')
N = 100
width = len(dut.a__data)
mask = int('1' * width, 2)
data = [getrandbits(width) for _ in range(N)]
expected = [(d + 1) & mask for d in data]
cocotb.fork(stream_input.send(data))
recved = await stream_output.recv(N)
assert recved == expected
if __name__ == '__main__':
core = Incrementador(5)
run(core,
'example',
ports=[*list(core.a.fields.values()), *list(core.r.fields.values())],
vcd_file='incrementador.vcd')
# If sum > maxlim, it restarts forward from the negatives
minlim + (a + b - maxlim - 1) if (a + b) > maxlim
# If sum < minlim, it restarts backwards from the positives
else maxlim - (minlim - a - b - 1) if (a + b) < minlim else (a + b)
for a, b in zip(data_a, data_b)
]
cocotb.fork(stream_input_a.send(data_a))
# Waits 10 posedge before sending data_b, to check if a will hold its value until b picks it up
for _ in range(10):
await RisingEdge(dut.clk)
cocotb.fork(stream_input_b.send(data_b))
res = await stream_output.recv(N)
assert res == expected
if __name__ == '__main__':
core = Binary_Adder(8)
run(
core,
'Binary_Adder',
ports=[
*list(core.a.fields.values()), *list(core.b.fields.values()),
*list(core.r.fields.values())
],
vcd_file='binary_adder.vcd',
)
cocotb.fork(stream_input_a.send(data_a))
cocotb.fork(stream_input_b.send(data_b))
# se llama al proceso recv para el stream_output y se espera a que este termine. recv lo que hace es que
# en cada rise del clock, si r.valid es 1 ==> se copia el valor de r.data en en la lista 'data', definida dentro de recv.
# Finalmente 'recv' devuelve esta lista.
recved = await stream_output.recv(N)
# se chequea si recved, es decir, los datos recibidos, coinciden con los datos esperados
assert recved == expected
# =======================================================
'''
Main programa
'''
# Inicico del programa
if __name__ == '__main__':
N_in = 8 # cantidad de bits de las streams de entrada 'a' y 'b'
N_out = 16 # cantidad de bits del stream de salida, 'r''
core = Adder(N_in, N_out) # "core" es una instancia de la clase Adder
run(core,
'entrega_ej_1',
ports=[
*list(core.a.fields.values()), *list(core.b.fields.values()),
*list(core.r.fields.values())
],
vcd_file='adder.vcd')
rst <= (1 if logic == 'negative' else 0)
@cocotb.test()
def fast_to_slow(dut):
axi_input = AxiStream(dut, 'input_', get_clock_signal(dut, CD_I))
axi_output = AxiStream(dut, 'output_', get_clock_signal(dut, CD_O))
init_axis_signals(axi_input, 'input')
init_axis_signals(axi_output, 'output')
start_clock(dut, CD_I, 10, 'ns')
start_clock(dut, CD_O, 20, 'ns')
yield Combine(reset_pulse(dut, CD_I), reset_pulse(dut, CD_O))
yield Timer(100, 'ns')
def get_ports(m):
ports = [m.input[f] for f in m.input.fields]
ports += [m.output[f] for f in m.output.fields]
return ports
if __name__ == '__main__':
fifo = AxiStreamFifo(width=50, depth=256, cd_i=CD_I, cd_o=CD_O)
run(fifo,
'nmigen_axi.test.axi_stream.test_fifo',
ports=get_ports(fifo),
vcd_file='output.vcd')
def test_ej6(width_in, width_gain, width_out):
from ej6 import Gain
core = Gain(width_in=width_in, width_gain=width_gain, width_out=width_out)
ports = [core.input, core.gain, core.output]
run(core, 'tb_ej6', ports=ports, vcd_file=waveform_dir + '/ej6.vcd')
def test_ej5(width_in, width_out):
from ej5 import Mean8
core = Mean8(width_in=width_in, width_out=width_out)
ports = [*core.inputs, core.output]
run(core, 'tb_ej5', ports=ports, vcd_file=waveform_dir + '/ej5.vcd')
def test_ej4(width_in, width_out):
from ej4 import RoundConvergent
core = RoundConvergent(width_in=width_in, width_out=width_out)
ports = [core.input, core.output]
run(core, 'tb_ej4', ports=ports, vcd_file=waveform_dir + '/ej4.vcd')
def test_ej3(width_in, width_out):
from ej3 import RoundNearest
core = RoundNearest(width_in=width_in, width_out=width_out)
ports = [core.input, core.output]
run(core, 'tb_ej3', ports=ports, vcd_file=waveform_dir + '/ej3.vcd')
await init_test(dut)
stream_input_a = Stream.Driver(dut.clk, dut, 'a__')
stream_input_b = Stream.Driver(dut.clk, dut, 'b__')
stream_output = Stream.Driver(dut.clk, dut, 'r__')
N = 100
width = len(dut.a__data)
mask = int('1' * width, 2)
data_a = [getrandbits(width) for _ in range(N)]
data_b = [getrandbits(width) for _ in range(N)]
expected = [(a + b) & mask for a in data_a for b in data_b]
cocotb.fork(stream_input_a.send(data_a))
cocotb.fork(stream_input_b.send(data_b))
recved = await stream_output.recv(N)
assert recved == expected
if __name__ == '__main__':
core = Sumador(5)
run(core,
'ej1',
ports=[
*list(core.a.fields.values()), *list(core.b.fields.values()),
*list(core.r.fields.values())
],
vcd_file='sumador.vcd')
def test_main(width, leak):
os.environ['coco_param_leak'] = str(leak)
core = Relu(width=width, leak=leak)
ports = core.get_ports()
vcd_file = vcd_only_if_env(f'./test_relu_w{width}_l{leak}.vcd')
run(core, 'cnn.tests.test_relu', ports=ports, vcd_file=vcd_file)
def test_ej1(width):
from ej1 import Suma6
core = Suma6(width)
ports = core.inputs
ports.append(core.output)
run(core, 'tb_ej1', ports=ports, vcd_file=waveform_dir + '/ej1.vcd')
expected = [(a + b) & mask for a, b in zip(data_a, data_b)]
# for a, b, r in zip(data_a, data_b, expected):
# dut._log.info("[a]:{:02X}, [b]:{:02X}, [r]:{:02X}".format(a, b, r))
send_a = cocotb.fork(stream_input_a.send(data_a))
send_b = cocotb.fork(stream_input_b.send(data_b))
send_a.join()
send_b.join()
received = await stream_output.recv(N)
for expctd, rcvd in zip(expected, received):
if expctd != rcvd:
dut._log.info("Expected {} Got {}".format(expctd, rcvd))
raise TestFailure("Test failed")
raise TestSuccess("Test passed")
if __name__ == '__main__':
core = Adder(5)
run(core,
'test_adder',
ports=[
*list(core.a.fields.values()), *list(core.b.fields.values()),
*list(core.r.fields.values())
],
vcd_file='adder.vcd')
def test_ej2(width_in, width_out):
from ej2 import Truncador
core = Truncador(width_in=width_in, width_out=width_out)
ports = [core.input, core.output]
run(core, 'tb_ej2', ports=ports, vcd_file=waveform_dir + '/ej2.vcd')
