def test_connectivity(self) -> None:
self.assertEqual(len(self.pb.constraints), 3)
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add().name = 'sink1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add().name = 'sink2'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, self.pb.constraints.values())
def test_connectivity(self) -> None:
pb = ExportedImplicitConnectBlock()._elaborated_def_to_proto()
self.assertEqual(len(pb.constraints),
5) # including source export, connect, port required
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'implicit_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add(
).name = 'block_sink_0'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'implicit_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add(
).name = 'block_sink_1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def test_connects(self) -> None:
self.assertEqual(
len(self.pb.constraints), 6
) # TODO: maybe filter by connection types in future for robustness
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add().name = 'source'
expected_conn.exported.exterior_port.ref.steps.add().name = 'a'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'a_net'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'source'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.map_extract.container.ref.steps.add(
).name = 'sinks'
expected_conn.exported.exterior_port.map_extract.path.steps.add(
).name = 'a'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'a_net'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sinks'
expected_conn.exported.internal_block_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add().name = 'source'
expected_conn.exported.exterior_port.ref.steps.add().name = 'b'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'b_net'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'source'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.map_extract.container.ref.steps.add(
).name = 'sinks'
expected_conn.exported.exterior_port.map_extract.path.steps.add(
).name = 'b'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'b_net'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sinks'
expected_conn.exported.internal_block_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
self.assertIn(expected_conn, self.pb.constraints.values())
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.literal.text.val = self.value
return pb
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.ref.CopyFrom(ref_map[expr])
return pb
def test_exported_hierarchy(self):
compiled_design = ScalaCompiler.compile(ExportPortHierarchyBlockTop)
pb = compiled_design.contents.blocks['block'].hierarchy
self.assertEqual(
pb.self_class.target.name,
'edg_core.test_hierarchy_block.ExportPortHierarchyBlock')
self.assertEqual(len(pb.ports), 1)
self.assertEqual(pb.ports['exported'].port.self_class.target.name,
'edg_core.test_common.TestPortSink')
self.assertEqual(len(pb.blocks), 1)
self.assertEqual(pb.blocks['sink'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSink')
self.assertEqual(
pb.blocks['sink'].hierarchy.ports['sink'].port.self_class.target.
name, 'edg_core.test_common.TestPortSink')
self.assertEqual(len(pb.links), 0)
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add().name = 'exported'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sink'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.ref.CopyFrom(ref_map[self.src])
pb.ref.steps.add().reserved_param = edgir.LENGTH
return pb
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.unary_set.op = self.op_map[self.op]
pb.unary_set.vals.CopyFrom(self.src._expr_to_proto(ref_map))
return pb
def make_assign(
target: ConstraintExpr, value: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.assign.dst.CopyFrom(ref_map[target])
pb.assign.src.CopyFrom(value._expr_to_proto(ref_map))
return pb
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.literal.range.minimum.floating.val = self.value.lower
pb.literal.range.maximum.floating.val = self.value.upper
return pb
def test_constraints(self):
# partial test of constraints, only the ones that are more interesting than tested elsewhere
# namely, ones that deal with map and reduce operations
expected_constr = edgir.ValueExpr()
expected_constr.assign.dst.steps.add().name = 'float_param_sink_range'
expected_constr.assign.src.binary.op = edgir.BinaryExpr.RANGE
expected_constr.assign.src.binary.lhs.unary_set.op = edgir.UnarySetExpr.MINIMUM
expected_constr.assign.src.binary.lhs.unary_set.vals.map_extract.container.ref.steps.add(
).name = 'sinks'
expected_constr.assign.src.binary.lhs.unary_set.vals.map_extract.path.steps.add(
).name = 'float_param'
expected_constr.assign.src.binary.rhs.unary_set.op = edgir.UnarySetExpr.MAXIMUM
expected_constr.assign.src.binary.rhs.unary_set.vals.map_extract.container.ref.steps.add(
).name = 'sinks'
expected_constr.assign.src.binary.rhs.unary_set.vals.map_extract.path.steps.add(
).name = 'float_param'
self.assertIn(expected_constr, self.pb.constraints.values())
expected_constr = edgir.ValueExpr()
expected_constr.binary.op = edgir.BinaryExpr.WITHIN
expected_constr.binary.lhs.ref.steps.add().name = 'source'
expected_constr.binary.lhs.ref.steps.add().name = 'float_param'
expected_constr.binary.rhs.ref.steps.add().name = 'source'
expected_constr.binary.rhs.ref.steps.add().name = 'float_param_limit'
self.assertIn(expected_constr, self.pb.constraints.values())
expected_constr = edgir.ValueExpr()
expected_name = '(init)range_param_sink_common'
expected_constr.assign.dst.steps.add().name = 'range_param_sink_common'
expected_constr.assign.src.unary_set.op = edgir.UnarySetExpr.INTERSECTION
expected_constr.assign.src.unary_set.vals.map_extract.container.ref.steps.add(
).name = 'sinks'
expected_constr.assign.src.unary_set.vals.map_extract.path.steps.add(
).name = 'range_limit'
self.assertEqual(expected_constr, self.pb.constraints[expected_name])
expected_constr = edgir.ValueExpr()
expected_constr.binary.op = edgir.BinaryExpr.WITHIN
expected_constr.binary.lhs.ref.steps.add().name = 'source'
expected_constr.binary.lhs.ref.steps.add().name = 'range_param'
expected_constr.binary.rhs.ref.steps.add(
).name = 'range_param_sink_common'
self.assertIn(expected_constr, self.pb.constraints.values())
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.ifThenElse.cond.CopyFrom(self.cond._expr_to_proto(ref_map))
pb.ifThenElse.tru.CopyFrom(self.then_val._expr_to_proto(ref_map))
pb.ifThenElse.fal.CopyFrom(self.else_val._expr_to_proto(ref_map))
return pb
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
pb = edgir.ValueExpr()
pb.binary.op = edgir.BinaryExpr.RANGE
pb.binary.lhs.CopyFrom(self.lower._expr_to_proto(ref_map))
pb.binary.rhs.CopyFrom(self.upper._expr_to_proto(ref_map))
return pb
def verify_pb(self, pb: edgir.HierarchyBlock) -> None:
self.assertEqual(len(pb.constraints),
5) # including source export, connect, port required
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_chain_0'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'output'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_chain_0'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add().name = 'inout'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_chain_0'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add().name = 'inputoutput'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_chain_1'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'inputoutput'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_chain_1'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
expected_conn.connected.block_port.ref.steps.add().name = 'input'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def expr_to_proto(
self, expr: ConstraintExpr,
ref_map: IdentityDict[Refable,
edgir.LocalPath]) -> edgir.ValueExpr:
contained_map = self.container._get_contained_ref_map()
pb = edgir.ValueExpr()
pb.map_extract.container.ref.CopyFrom(
ref_map[self.container]) # TODO support arbitrary refs
pb.map_extract.path.CopyFrom(contained_map[self.elt])
return pb
def test_footprint(self):
self.assertIn(
edgir.AssignLit(['footprint_name'],
'Resistor_SMD:R_0603_1608Metric'),
self.pb.constraints.values())
self.assertIn(edgir.AssignLit(['value'], '1k'),
self.pb.constraints.values())
self.assertIn(edgir.AssignLit(['refdes_prefix'], 'R'),
self.pb.constraints.values())
expected_pinning = edgir.Metadata()
path = edgir.ValueExpr()
path.ref.steps.add().name = 'port_1'
expected_pinning.members.node['1'].bin_leaf = path.SerializeToString()
path = edgir.ValueExpr()
path.ref.steps.add().name = 'port_2'
expected_pinning.members.node['2'].bin_leaf = path.SerializeToString()
self.assertEqual(self.pb.meta.members.node['pinning'],
expected_pinning)
def test_connectivity(self) -> None:
self.assertEqual(len(self.pb.constraints), 1)
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add().name = 'exported'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sink'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'sink'
self.assertIn(expected_conn, self.pb.constraints.values())
def test_connectivity(self) -> None:
pb = AdapterTestTop()._elaborated_def_to_proto()
self.assertEqual(
pb.blocks['(adapter)adapter_src.port'].lib_elem.target.name,
"edg_core.test_port_adapter.AdapterPortAdapter")
# ignore the other blocks
self.assertEqual(len(pb.constraints), 4)
expected_conn = edgir.ValueExpr()
expected_conn.connected.block_port.ref.steps.add().name = 'adapter_src'
expected_conn.connected.block_port.ref.steps.add().name = 'port'
expected_conn.connected.link_port.ref.steps.add(
).name = '(adapter_net)adapter_src.port'
expected_conn.connected.link_port.ref.steps.add().name = 'ports'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add(
).name = '(adapter_net)adapter_src.port'
expected_conn.connected.link_port.ref.steps.add().name = 'ports'
expected_conn.connected.block_port.ref.steps.add(
).name = '(adapter)adapter_src.port'
expected_conn.connected.block_port.ref.steps.add().name = 'src'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.block_port.ref.steps.add(
).name = '(adapter)adapter_src.port'
expected_conn.connected.block_port.ref.steps.add().name = 'dst'
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def test_constraints(self):
self.assertEqual(len(self.pb.constraints), 2)
expected_constr = edgir.ValueExpr()
expected_constr.assign.dst.steps.add().name = 'outer_port'
expected_constr.assign.dst.steps.add().name = 'float_param'
expected_constr.assign.src.ref.steps.add().name = 'inner_link'
expected_constr.assign.src.ref.steps.add(
).reserved_param = edgir.CONNECTED_LINK
expected_constr.assign.src.ref.steps.add(
).name = 'float_param_sink_sum'
self.assertIn(expected_constr, self.pb.constraints.values())
expected_constr = edgir.ValueExpr()
expected_constr.binary.op = edgir.BinaryExpr.EQ
expected_constr.assign.dst.steps.add().name = 'outer_port'
expected_constr.assign.dst.steps.add().name = 'range_limit'
expected_constr.assign.src.ref.steps.add().name = 'inner_link'
expected_constr.assign.src.ref.steps.add(
).reserved_param = edgir.CONNECTED_LINK
expected_constr.assign.src.ref.steps.add(
).name = 'range_param_sink_common'
self.assertIn(expected_constr, self.pb.constraints.values())
def test_connectivity(self) -> None:
self.assertEqual(len(self.pb.constraints), 4)
expected_conn = edgir.ValueExpr()
expected_conn.connected.block_port.ref.steps.add(
).name = '(bridge)source_port'
expected_conn.connected.block_port.ref.steps.add().name = 'inner_link'
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add(
).name = 'source_port'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = '(bridge)source_port'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'outer_port'
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.block_port.ref.steps.add().name = 'sink1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
self.assertIn(expected_conn, self.pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.block_port.ref.steps.add().name = 'sink2'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add(
).reserved_param = edgir.ALLOCATE
self.assertIn(expected_conn, self.pb.constraints.values())
def test_bridge_hierarchy(self):
compiled_design = ScalaCompiler.compile(PortBridgeHierarchyBlockTop)
pb = compiled_design.contents.blocks['block'].hierarchy
self.assertEqual(
pb.self_class.target.name,
'edg_core.test_hierarchy_block.PortBridgeHierarchyBlock')
self.assertEqual(len(pb.ports), 1)
self.assertEqual(pb.ports['source_port'].port.self_class.target.name,
"edg_core.test_common.TestPortSink")
self.assertEqual(len(pb.blocks), 3)
self.assertEqual(
pb.blocks['(bridge)source_port'].hierarchy.self_class.target.name,
'edg_core.test_common.TestPortBridge')
self.assertEqual(
pb.blocks['(bridge)source_port'].hierarchy.ports['inner_link'].
port.self_class.target.name, "edg_core.test_common.TestPortSource")
self.assertEqual(
pb.blocks['(bridge)source_port'].hierarchy.ports['outer_port'].
port.self_class.target.name, "edg_core.test_common.TestPortSink")
self.assertEqual(pb.blocks['sink1'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSink')
self.assertEqual(
pb.blocks['sink1'].hierarchy.ports['sink'].port.self_class.target.
name, 'edg_core.test_common.TestPortSink')
self.assertEqual(pb.blocks['sink2'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSink')
self.assertEqual(
pb.blocks['sink2'].hierarchy.ports['sink'].port.self_class.target.
name, 'edg_core.test_common.TestPortSink')
self.assertEqual(len(pb.links), 1)
self.assertEqual(pb.links['test_net'].link.self_class.target.name,
'edg_core.test_common.TestLink')
self.assertEqual(
pb.links['test_net'].link.ports['source'].port.self_class.target.
name, "edg_core.test_common.TestPortSource")
self.assertEqual(
pb.links['test_net'].link.ports['sinks'].array.ports['0'].port.
self_class.target.name, "edg_core.test_common.TestPortSink")
self.assertEqual(
pb.links['test_net'].link.ports['sinks'].array.ports['1'].port.
self_class.target.name, "edg_core.test_common.TestPortSink")
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add(
).name = '(bridge)source_port'
expected_conn.connected.block_port.ref.steps.add().name = 'inner_link'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.exported.exterior_port.ref.steps.add(
).name = 'source_port'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = '(bridge)source_port'
expected_conn.exported.internal_block_port.ref.steps.add(
).name = 'outer_port'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add().name = '0'
expected_conn.connected.block_port.ref.steps.add().name = 'sink1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add().name = '1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink2'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def process_blocklike(self, path: TransformUtil.Path,
block: edgir.BlockLikeTypes) -> None:
# generate short paths for children first
short_path = self.short_paths[path]
if 'error' in block.meta.members.node:
raise InvalidNetlistBlockException(
f"attempt to netlist with error block at {path}")
elif 'abstract' in block.meta.members.node:
raise InvalidNetlistBlockException(
f"attempt to netlist with abstract block at {path}")
if isinstance(block, edgir.HierarchyBlock):
self.hierarchy[path] = block.self_class.target.name
# TODO handle mixed net/connect operations
if isinstance(block, edgir.Link) and 'nets' in block.meta.members.node:
# Conslidate single-net link ports into just the link
for name, _ in block.ports.items():
self.short_paths[path.append_port(name)] = short_path
else:
for name, _ in block.ports.items():
self.short_paths[path.append_port(
name)] = short_path.append_port(name)
for name, _ in block.links.items():
self.short_paths[path.append_link(name)] = short_path.append_link(
name)
main_internal_block_names: List[str] = []
other_internal_block_names: List[str] = []
if isinstance(block, edgir.HierarchyBlock):
main_internal_block_names += [
block_name for block_name in block.blocks.keys()
if not block_name.startswith('(bridge)')
and not block_name.startswith('(adapter)')
]
other_internal_block_names += [
block_name for block_name in block.blocks.keys()
if block_name not in main_internal_block_names
]
if len(main_internal_block_names) == 1:
name = main_internal_block_names[0]
self.short_paths[path.append_block(name)] = short_path
for name in other_internal_block_names:
self.short_paths[path.append_block(
name)] = short_path.append_block(name)
else:
for name in main_internal_block_names + other_internal_block_names:
self.short_paths[path.append_block(
name)] = short_path.append_block(name)
if 'nets' in block.meta.members.node:
# add all-pairs edges
# list conversion to deal with iterable-once
flat_ports = list(
chain(*[
flatten_port(path.append_port(name), port)
for name, port in block.ports.items()
]))
for src_path in flat_ports:
for dst_path in flat_ports:
if src_path != dst_path:
self.edges.setdefault(src_path, []).append(dst_path)
if 'pinning' in block.meta.members.node:
# vals = find_constraints({'footprint_name', 'mfr', 'part', 'value', 'refdes_prefix'}, block.constraints.values())
footprint_name = self.design.get_value(path.to_tuple() +
('footprint_name', ))
mfr = self.design.get_value(path.to_tuple() + ('mfr', ))
part = self.design.get_value(path.to_tuple() + ('part', ))
value = self.design.get_value(path.to_tuple() + ('value', ))
refdes_prefix = self.design.get_value(path.to_tuple() +
('refdes_prefix', ))
lcsc_part = self.design.get_value(path.to_tuple() +
('lcsc_part', ))
assert isinstance(footprint_name, str)
assert isinstance(mfr, str) or mfr is None
assert isinstance(part, str) or part is None
assert isinstance(value, str) or value is None
assert isinstance(lcsc_part, str) or lcsc_part is None
assert isinstance(refdes_prefix, str)
part_comps = [part, f"({mfr})" if mfr else ""]
part_str = " ".join(filter(None, part_comps))
value_comps = [part_str, value]
value_str = " - ".join(filter(None, value_comps))
self.blocks[path] = (
footprint_name,
# Uncomment one to set value field
# TODO this should be a user flag
value_str
# lcsc_part or ""
)
refdes_id = self.refdes_last.get(refdes_prefix, 0) + 1
self.refdes_last[refdes_prefix] = refdes_id
# Uncomment one to set refdes type
# TODO this should be a user flag
# self.names[path] = TransformUtil.Path.empty().append_block(refdes_prefix + str(refdes_id))
self.names[path] = self.short_paths[path]
for pin_name, pin_path_pb in block.meta.members.node[
'pinning'].members.node.items():
pin_path = path.append_port(pin_name)
self.pins.add(pin_path)
self.short_paths[pin_path] = short_path.append_port(pin_name)
path_value = edgir.ValueExpr().FromString(pin_path_pb.bin_leaf)
assert path_value.HasField('ref')
src_path = path.follow(path_value.ref, block)[0]
# Create a unidirectional edge from the port to the footprint pin
self.edges.setdefault(src_path, []).append(pin_path)
self.edges.setdefault(pin_path, []) # create a dummy entry
self.names[pin_path] = self.names[path].append_port(pin_name)
for name, constraint in block.constraints.items():
if constraint.HasField('connected'):
self.process_connected(path, block, constraint.connected)
elif constraint.HasField('exported'):
self.process_exported(path, block, constraint.exported)
def test_single_hierarchy(self):
"""
Tests design instantiation with a single level of hierarchy blocks.
Only tests that the contained blocks are instantiated and structurally correct, does not check internal constraints
"""
compiled_design = ScalaCompiler.compile(TopHierarchyBlock)
pb = compiled_design.contents
self.assertEqual(pb.self_class.target.name,
'edg_core.test_hierarchy_block.TopHierarchyBlock')
self.assertEqual(len(pb.blocks), 3)
self.assertEqual(pb.blocks['source'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSource')
self.assertEqual(
pb.blocks['source'].hierarchy.ports['source'].port.self_class.
target.name, 'edg_core.test_common.TestPortSource')
self.assertEqual(pb.blocks['sink1'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSink')
self.assertEqual(
pb.blocks['sink1'].hierarchy.ports['sink'].port.self_class.target.
name, 'edg_core.test_common.TestPortSink')
self.assertEqual(pb.blocks['sink2'].hierarchy.self_class.target.name,
'edg_core.test_common.TestBlockSink')
self.assertEqual(
pb.blocks['sink2'].hierarchy.ports['sink'].port.self_class.target.
name, 'edg_core.test_common.TestPortSink')
self.assertEqual(pb.links['test_net'].link.self_class.target.name,
'edg_core.test_common.TestLink')
self.assertEqual(
pb.links['test_net'].link.ports['source'].port.self_class.target.
name, "edg_core.test_common.TestPortSource")
self.assertEqual(
pb.links['test_net'].link.ports['sinks'].array.ports['0'].port.
self_class.target.name, "edg_core.test_common.TestPortSink")
self.assertEqual(
pb.links['test_net'].link.ports['sinks'].array.ports['1'].port.
self_class.target.name, "edg_core.test_common.TestPortSink")
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
expected_conn.connected.block_port.ref.steps.add().name = 'source'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add().name = '0'
expected_conn.connected.block_port.ref.steps.add().name = 'sink1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
expected_conn = edgir.ValueExpr()
expected_conn.connected.link_port.ref.steps.add().name = 'test_net'
expected_conn.connected.link_port.ref.steps.add().name = 'sinks'
expected_conn.connected.link_port.ref.steps.add().name = '1'
expected_conn.connected.block_port.ref.steps.add().name = 'sink2'
expected_conn.connected.block_port.ref.steps.add().name = 'sink'
self.assertIn(expected_conn, pb.constraints.values())
def refable_to_path_expr(ref: Refable) -> edgir.ValueExpr:
expr = edgir.ValueExpr()
expr.ref.CopyFrom(ref_map[ref])
return expr
