def test_wireable():
c = coreir.Context()
module_typ = c.Record({"input": c.Array(8, c.BitIn()), "output": c.Array(9, c.Bit())})
module = c.global_namespace.new_module("multiply_by_2", module_typ)
# module.print()
module_def = module.new_definition()
add8 = c.global_namespace.new_module("add8",
c.Record({
"in1": c.Array(8, c.BitIn()),
"in2": c.Array(8, c.BitIn()),
"out": c.Array(9, c.Bit())
})
)
add8_inst = module_def.add_module_instance("adder", add8)
add8_in1 = add8_inst.select("in1")
add8_in2 = add8_inst.select("in2")
add8_out = add8_inst.select("out")
interface = module_def.interface
_input = interface.select("input")
output = interface.select("output")
module_def.connect(_input, add8_in1)
module_def.connect(_input, add8_in2)
module_def.connect(output, add8_out)
actual = [get_pointer_addr(wireable.ptr) for wireable in _input.connected_wireables]
assert get_pointer_addr(add8_in1.ptr) in actual
assert get_pointer_addr(add8_in2.ptr) in actual
for expected, actual in zip(['adder', 'out'], add8_out.selectpath):
assert expected == actual
wireable = module_def.select("self")
select = wireable.select("input")
assert isinstance(select, coreir.Select)
assert get_pointer_addr(select.ptr) == get_pointer_addr(_input.ptr)
assert select.parent == wireable
def test_module_def_instances():
c = coreir.Context()
module_typ = c.Record({
"input": c.Array(8, c.BitIn()),
"output": c.Array(9, c.Bit())
})
module = c.G.new_module("multiply_by_2", module_typ)
module_def = module.new_definition()
add8 = c.G.new_module(
"add8",
c.Record({
"in1": c.Array(8, c.BitIn()),
"in2": c.Array(8, c.BitIn()),
"out": c.Array(9, c.Bit())
}))
add8_inst_1 = module_def.add_module_instance("adder1", add8)
add8_inst_2 = module_def.add_module_instance("adder2", add8)
instances = module_def.instances
pointers_actual = [get_pointer_addr(inst.ptr) for inst in instances]
pointers_expected = [
get_pointer_addr(inst.ptr) for inst in [add8_inst_1, add8_inst_2]
]
for pointer in pointers_actual:
assert pointer in pointers_expected
pointers_expected.remove(pointer)
assert not len(pointers_expected), "Missing pointers {}".format(
pointers_expected)
assert_pointers_equal(instances[0].module_def.ptr, module_def.ptr)
assert_pointers_equal(instances[0].module.ptr, module.ptr)
def test_module_def_select():
c = coreir.Context()
module_typ = c.Record({"input": c.Array(8, c.BitIn()), "output": c.Array(9, c.Bit())})
module = c.global_namespace.new_module("multiply_by_2", module_typ)
# module.print()
module_def = module.new_definition()
add8 = c.global_namespace.new_module("add8",
c.Record({
"in1": c.Array(8, c.BitIn()),
"in2": c.Array(8, c.BitIn()),
"out": c.Array(9, c.Bit())
})
)
interface = module_def.interface
assert get_pointer_addr(interface.ptr) == get_pointer_addr(module_def.select("self").ptr)
add8_inst = module_def.add_module_instance("adder", add8)
add8_inst_select = module_def.select("adder")
assert get_pointer_addr(add8_inst.ptr) == get_pointer_addr(add8_inst_select.ptr)
def test_module_def_connections():
c = coreir.Context()
module_typ = c.Record({
"input": c.Array(8, c.BitIn()),
"output": c.Array(9, c.Bit())
})
module = c.G.new_module("multiply_by_2", module_typ)
# module.print()
module_def = module.new_definition()
add8 = c.G.new_module(
"add8",
c.Record({
"in1": c.Array(8, c.BitIn()),
"in2": c.Array(8, c.BitIn()),
"out": c.Array(9, c.Bit())
}))
add8_inst = module_def.add_module_instance("adder", add8)
add8_in1 = add8_inst.select("in1")
add8_in2 = add8_inst.select("in2")
add8_out = add8_inst.select("out")
interface = module_def.interface
_input = interface.select("input")
output = interface.select("output")
module_def.connect(_input, add8_in1)
module_def.connect(_input, add8_in2)
module_def.connect(output, add8_out)
input_ptr = get_pointer_addr(_input.ptr)
add8_in1_ptr = get_pointer_addr(add8_in1.ptr)
add8_in2_ptr = get_pointer_addr(add8_in2.ptr)
add8_out_ptr = get_pointer_addr(add8_out.ptr)
output_ptr = get_pointer_addr(output.ptr)
expected_conns = [(add8_in1_ptr, input_ptr, 8),
(add8_in2_ptr, input_ptr, 8),
(add8_out_ptr, output_ptr, 9)]
connections = module_def.connections
seen = []
for conn in connections:
conn_info = (get_pointer_addr(conn.first.ptr),
get_pointer_addr(conn.second.ptr), conn.size)
reverse_conn_info = (conn_info[1], conn_info[0], conn.size)
# Should be in expected, shouldn't see it twice
assert (conn_info in expected_conns or reverse_conn_info in expected_conns) and \
conn_info not in seen
seen.append(conn_info)
assert len(seen) == len(expected_conns)
def test_directed_module():
c = coreir.Context()
module_typ = c.Record({
"input": c.Array(8, c.BitIn()),
"output": c.Array(8, c.Bit())
})
module = c.G.new_module("multiply_by_4", module_typ)
module_def = module.new_definition()
add8 = c.G.new_module(
"add8",
c.Record({
"in1": c.Array(8, c.BitIn()),
"in2": c.Array(8, c.BitIn()),
"out": c.Array(8, c.Bit())
}))
add8_inst1 = module_def.add_module_instance("adder1", add8)
add8_inst2 = module_def.add_module_instance("adder2", add8)
add8_inst3 = module_def.add_module_instance("adder3", add8)
interface = module_def.interface
_input = interface.select("input")
for adder in [add8_inst1, add8_inst2]:
module_def.connect(_input, adder.select("in1"))
module_def.connect(_input, adder.select("in2"))
module_def.connect(add8_inst1.select("out"), add8_inst3.select("in1"))
module_def.connect(add8_inst2.select("out"), add8_inst3.select("in2"))
module_def.connect(add8_inst3.select("out"), interface.select("output"))
module.definition = module_def
directed_module = module.directed_module
# check inputs
expected = [["adder1", "in1"], ["adder1", "in2"], ["adder2", "in1"],
["adder2", "in2"]]
for input in directed_module.inputs:
assert input.source == ["self", "input"]
assert input.sink in expected, "Unexpected sink {}".format(input.sink)
expected.remove(input.sink)
assert len(expected) == 0, "Did not find {}".format(expected)
# check outputs
expected = [["adder3", "out"]]
for output in directed_module.outputs:
assert output.sink == ["self", "output"]
assert output.source in expected, "Unexpected source {}".format(
input.sink)
expected.remove(output.source)
assert len(expected) == 0, "Did not find {}".format(expected)
assert get_pointer_addr(directed_module.sel(
["adder3",
"out"]).ptr) == get_pointer_addr(add8_inst3.select("out").ptr)
expected = [(['adder3', 'out'], ['self', 'output'], 8),
(['adder2', 'out'], ['adder3', 'in2'], 8),
(['adder1', 'out'], ['adder3', 'in1'], 8),
(['self', 'input'], ['adder1', 'in1'], 8),
(['self', 'input'], ['adder2', 'in1'], 8),
(['self', 'input'], ['adder1', 'in2'], 8),
(['self', 'input'], ['adder2', 'in2'], 8)]
for directed_connection in directed_module.connections:
actual = (directed_connection.source, directed_connection.sink,
directed_connection.size)
assert actual in expected
expected.remove(actual)
assert len(expected) == 0
# check instances
for instance in directed_module.instances:
for input in instance.inputs:
assert input.source in [["self", "input"], ["adder1", "out"],
["adder2", "out"]]
assert input.sink[0] in ["adder1", "adder2", "adder3"]
assert input.sink[1] in ["in1", "in2"]
for output in instance.outputs:
assert output.source[0] in ["adder1", "adder2", "adder3"]
assert output.source[1] == "out"
assert output.sink in [["self", "output"], ["adder3", "in1"],
["adder3", "in2"]]
