From fb7ef864c019d325f3fc37125e6d6cdc50ae4b83 Mon Sep 17 00:00:00 2001 From: Patrick Lehmann Date: Thu, 12 Jan 2023 05:53:48 +0100 Subject: Dependency Graphs (#2308) * Further fixes to the example code. * Bumped dependencies. * Fixed Debouncer example code. * Some more cleanup. * Black's opinion. * Run with pyVHDLModel dev-branch. * Fixed imports for Name. * Fixed test case. * Added a formatter to write dependency graphs and hierarchy as graphml. * Improved GraphML formatting. * Write compile order graph. * Computing compile order. * Bumped dependencies. * Black's opinion. * Fixed incorrect dependency. --- pyGHDL/cli/requirements.txt | 2 +- pyGHDL/dom/Aggregates.py | 17 +- pyGHDL/dom/Attribute.py | 14 +- pyGHDL/dom/Concurrent.py | 55 +++--- pyGHDL/dom/DesignUnit.py | 56 +++--- pyGHDL/dom/Expression.py | 31 ++-- pyGHDL/dom/InterfaceItem.py | 39 ++-- pyGHDL/dom/Literal.py | 19 +- pyGHDL/dom/Misc.py | 5 +- pyGHDL/dom/Names.py | 21 ++- pyGHDL/dom/NonStandard.py | 12 +- pyGHDL/dom/Object.py | 30 ++-- pyGHDL/dom/PSL.py | 10 +- pyGHDL/dom/Range.py | 2 +- pyGHDL/dom/Sequential.py | 56 +++--- pyGHDL/dom/Subprogram.py | 13 +- pyGHDL/dom/Symbol.py | 64 +++---- pyGHDL/dom/Type.py | 39 ++-- pyGHDL/dom/_Translate.py | 49 +++-- pyGHDL/dom/_Utils.py | 13 +- pyGHDL/dom/formatting/GraphML.py | 340 +++++++++++++++++++++++++++++++++++ pyGHDL/dom/formatting/prettyprint.py | 28 ++- pyGHDL/dom/requirements.txt | 2 +- pyGHDL/libghdl/requirements.txt | 2 +- 24 files changed, 604 insertions(+), 315 deletions(-) create mode 100644 pyGHDL/dom/formatting/GraphML.py (limited to 'pyGHDL') diff --git a/pyGHDL/cli/requirements.txt b/pyGHDL/cli/requirements.txt index e453bcbde..063ef74f6 100644 --- a/pyGHDL/cli/requirements.txt +++ b/pyGHDL/cli/requirements.txt @@ -1,5 +1,5 @@ -r ../dom/requirements.txt -pyTooling>=2.1.0 +pyTooling>=2.11.0 pyTooling.TerminalUI>=1.5.9 pyAttributes>=2.3.2 diff --git a/pyGHDL/dom/Aggregates.py b/pyGHDL/dom/Aggregates.py index a1fe40866..968d3afc9 100644 --- a/pyGHDL/dom/Aggregates.py +++ b/pyGHDL/dom/Aggregates.py @@ -41,15 +41,14 @@ This module contains all DOM classes for VHDL's design units (:class:`context List: @export def GetArrayConstraintsFromSubtypeIndication( subtypeIndication: Iir, -) -> List[ConstraintUnion]: +) -> List: constraints = [] for constraint in utils.flist_iter(nodes.Get_Index_Constraint_List(subtypeIndication)): constraintKind = GetIirKindOfNode(constraint) @@ -303,13 +294,13 @@ def GetAnonymousTypeFromNode(node: Iir) -> BaseType: @export -def GetSubtypeIndicationFromNode(node: Iir, entity: str, name: str) -> SubtypeOrSymbol: +def GetSubtypeIndicationFromNode(node: Iir, entity: str, name: str) -> Symbol: subtypeIndicationNode = nodes.Get_Subtype_Indication(node) return GetSubtypeIndicationFromIndicationNode(subtypeIndicationNode, entity, name) @export -def GetSubtypeIndicationFromIndicationNode(subtypeIndicationNode: Iir, entity: str, name: str) -> SubtypeOrSymbol: +def GetSubtypeIndicationFromIndicationNode(subtypeIndicationNode: Iir, entity: str, name: str) -> Symbol: if subtypeIndicationNode is nodes.Null_Iir: raise ValueError("Parameter 'subtypeIndicationNode' is 'Null_Iir'.") @@ -331,7 +322,7 @@ def GetSubtypeIndicationFromIndicationNode(subtypeIndicationNode: Iir, entity: s @export def GetSimpleTypeFromNode(subtypeIndicationNode: Iir) -> SimpleSubtypeSymbol: subtypeName = GetNameFromNode(subtypeIndicationNode) - return SimpleSubtypeSymbol(subtypeIndicationNode, subtypeName) + return SimpleSubtypeSymbol(subtypeIndicationNode, str(subtypeName)) # XXX: hacked @export @@ -343,7 +334,7 @@ def GetScalarConstrainedSubtypeFromNode( simpleTypeMark = SimpleName(typeMark, typeMarkName) rangeConstraint = nodes.Get_Range_Constraint(subtypeIndicationNode) r = GetRangeFromNode(rangeConstraint) - return ConstrainedScalarSubtypeSymbol(subtypeIndicationNode, simpleTypeMark, r) + return ConstrainedScalarSubtypeSymbol(subtypeIndicationNode, str(simpleTypeMark), r) # XXX: hacked @export @@ -355,11 +346,11 @@ def GetCompositeConstrainedSubtypeFromNode( simpleTypeMark = SimpleName(typeMark, typeMarkName) constraints = GetArrayConstraintsFromSubtypeIndication(subtypeIndicationNode) - return ConstrainedCompositeSubtypeSymbol(subtypeIndicationNode, simpleTypeMark, constraints) + return ConstrainedCompositeSubtypeSymbol(subtypeIndicationNode, str(simpleTypeMark), constraints) # XXX: hacked @export -def GetSubtypeFromNode(subtypeNode: Iir) -> SubtypeOrSymbol: +def GetSubtypeFromNode(subtypeNode: Iir) -> Symbol: subtypeName = GetNameOfNode(subtypeNode) return Subtype(subtypeNode, subtypeName) diff --git a/pyGHDL/dom/_Utils.py b/pyGHDL/dom/_Utils.py index 09f336c03..7ab02ace9 100644 --- a/pyGHDL/dom/_Utils.py +++ b/pyGHDL/dom/_Utils.py @@ -34,6 +34,13 @@ from typing import Union from pyTooling.Decorators import export +from pyVHDLModel.Base import Mode + +from pyGHDL.libghdl import LibGHDLException, name_table, errorout_memory, files_map, file_comments +from pyGHDL.libghdl._types import Iir +from pyGHDL.libghdl.vhdl import nodes, utils +from pyGHDL.libghdl.vhdl.nodes import Null_Iir +from pyGHDL.dom import DOMException, Position from pyGHDL.dom.Symbol import ( LibraryReferenceSymbol, PackageReferenceSymbol, @@ -44,13 +51,7 @@ from pyGHDL.dom.Symbol import ( ComponentInstantiationSymbol, ConfigurationInstantiationSymbol, ) -from pyVHDLModel.SyntaxModel import Mode -from pyGHDL.libghdl import LibGHDLException, name_table, errorout_memory, files_map, file_comments -from pyGHDL.libghdl._types import Iir -from pyGHDL.libghdl.vhdl import nodes, utils -from pyGHDL.libghdl.vhdl.nodes import Null_Iir -from pyGHDL.dom import DOMException, Position __MODE_TRANSLATION = { nodes.Iir_Mode.In_Mode: Mode.In, diff --git a/pyGHDL/dom/formatting/GraphML.py b/pyGHDL/dom/formatting/GraphML.py new file mode 100644 index 000000000..7f72d54b5 --- /dev/null +++ b/pyGHDL/dom/formatting/GraphML.py @@ -0,0 +1,340 @@ +from pathlib import Path +from textwrap import dedent +from typing import Dict, List + +from pyTooling.Graph import Graph, Vertex + +from pyVHDLModel import ( + DependencyGraphVertexKind, + DependencyGraphEdgeKind, + Library as VHDLModel_Library, + Document as VHDLModel_Document, +) + + +class DependencyGraphFormatter: + _graph: Graph + + NODE_COLORS = { + DependencyGraphVertexKind.Document: "#999999", + DependencyGraphVertexKind.Library: "#99ccff", + DependencyGraphVertexKind.Package: "#ff9900", + DependencyGraphVertexKind.PackageBody: "#ff9900", + DependencyGraphVertexKind.Context: "#cc99ff", + DependencyGraphVertexKind.Entity: "#ffff99", + DependencyGraphVertexKind.Architecture: "#ff99cc", + DependencyGraphVertexKind.Configuration: "#ff9900", + } + EDGE_COLORS = { + DependencyGraphEdgeKind.SourceFile: "#000000", + DependencyGraphEdgeKind.CompileOrder: "#ff0000", + DependencyGraphEdgeKind.LibraryClause: "#000000", + DependencyGraphEdgeKind.UseClause: "#000000", + DependencyGraphEdgeKind.ContextReference: "#000000", + DependencyGraphEdgeKind.EntityImplementation: "#99ccff", + DependencyGraphEdgeKind.PackageImplementation: "#99ccff", + DependencyGraphEdgeKind.EntityInstantiation: "#000000", + DependencyGraphEdgeKind.ComponentInstantiation: "#000000", + DependencyGraphEdgeKind.ConfigurationInstantiation: "#000000", + } + + def __init__(self, graph: Graph): + self._graph = graph + + def WriteGraphML(self, path: Path): + with path.open("w") as file: + file.write( + dedent( + f"""\ + + + + + + + + + + """ + ) + ) + groups: Dict[str, List[Vertex]] = {} + for vertex in self._graph._verticesWithID.values(): + if isinstance(vertex.Value, VHDLModel_Library): + identifier = vertex.Value.NormalizedIdentifier + elif isinstance(vertex.Value, VHDLModel_Document): + identifier = vertex.Value.DesignUnits[0].Library.NormalizedIdentifier + else: + identifier = vertex.Value.Library.NormalizedIdentifier + + if identifier in groups: + groups[identifier].append(vertex) + else: + groups[identifier] = [vertex] + + for group, vertices in groups.items(): + file.write( + dedent( + """\ + {prefix} + {prefix} {value} + {prefix} + """ + ).format(prefix=" ", id=group, value=group) + ) + + for vertex in vertices: + if vertex["kind"] is DependencyGraphVertexKind.Architecture: + value = f"{vertex.Value.Entity.Identifier}({vertex.Value.Identifier})" + elif vertex["kind"] is DependencyGraphVertexKind.Document: + value = f"{vertex.ID}" + else: + value = f"{vertex.Value.Identifier}" + file.write( + dedent( + """\ + {prefix} + {prefix} {vertex.ID} + {prefix} {value} + {prefix} {vertex[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", vertex=vertex, value=value, color=self.NODE_COLORS[vertex["kind"]]) + ) + + file.write( + dedent( + """\ + {prefix} + {prefix} + """ + ).format(prefix=" ") + ) + + edgeCount = 1 + for edge in self._graph._edgesWithoutID: + file.write( + dedent( + """\ + {prefix} + {prefix} {edge[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", edgeCount=edgeCount, edge=edge, color=self.EDGE_COLORS[edge["kind"]]) + ) + edgeCount += 1 + + file.write( + dedent( + """\ + + + """ + ) + ) + + +class HierarchyGraphFormatter: + _graph: Graph + + NODE_COLORS = { + DependencyGraphVertexKind.Document: "#999999", + DependencyGraphVertexKind.Library: "#99ccff", + DependencyGraphVertexKind.Package: "#ff9900", + DependencyGraphVertexKind.PackageBody: "#ff9900", + DependencyGraphVertexKind.Context: "#cc99ff", + DependencyGraphVertexKind.Entity: "#ffff99", + DependencyGraphVertexKind.Architecture: "#ff99cc", + DependencyGraphVertexKind.Configuration: "#ff9900", + } + EDGE_COLORS = { + DependencyGraphEdgeKind.SourceFile: "#000000", + DependencyGraphEdgeKind.CompileOrder: "#ff0000", + DependencyGraphEdgeKind.LibraryClause: "#000000", + DependencyGraphEdgeKind.UseClause: "#000000", + DependencyGraphEdgeKind.ContextReference: "#000000", + DependencyGraphEdgeKind.EntityImplementation: "#99ccff", + DependencyGraphEdgeKind.PackageImplementation: "#99ccff", + DependencyGraphEdgeKind.EntityInstantiation: "#000000", + DependencyGraphEdgeKind.ComponentInstantiation: "#000000", + DependencyGraphEdgeKind.ConfigurationInstantiation: "#000000", + } + + def __init__(self, graph: Graph): + self._graph = graph + + def WriteGraphML(self, path: Path): + with path.open("w") as file: + file.write( + dedent( + f"""\ + + + + + + + + + + """ + ) + ) + + for vertex in self._graph._verticesWithID.values(): + if vertex["kind"] is DependencyGraphVertexKind.Entity: + file.write( + dedent( + """\ + {prefix} + {prefix} {vertex.ID} + {prefix} {vertex.Value.Identifier} + {prefix} {vertex[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", vertex=vertex, color=self.NODE_COLORS[vertex["kind"]]) + ) + elif vertex["kind"] is DependencyGraphVertexKind.Architecture: + file.write( + dedent( + """\ + {prefix} + {prefix} {vertex.ID} + {prefix} {vertex.Value.Identifier} + {prefix} {vertex[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", vertex=vertex, color=self.NODE_COLORS[vertex["kind"]]) + ) + + edgeCount = 1 + for edge in self._graph._edgesWithoutID: + file.write( + dedent( + """\ + {prefix} + {prefix} {edge[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", edgeCount=edgeCount, edge=edge, color=self.EDGE_COLORS[edge["kind"]]) + ) + edgeCount += 1 + + file.write( + dedent( + """\ + + + """ + ) + ) + + +class CompileOrderGraphFormatter: + _graph: Graph + + NODE_COLORS = { + DependencyGraphVertexKind.Document: "#999999", + DependencyGraphVertexKind.Library: "#99ccff", + DependencyGraphVertexKind.Package: "#ff9900", + DependencyGraphVertexKind.PackageBody: "#ff9900", + DependencyGraphVertexKind.Context: "#cc99ff", + DependencyGraphVertexKind.Entity: "#ffff99", + DependencyGraphVertexKind.Architecture: "#ff99cc", + DependencyGraphVertexKind.Configuration: "#ff9900", + } + EDGE_COLORS = { + DependencyGraphEdgeKind.SourceFile: "#000000", + DependencyGraphEdgeKind.CompileOrder: "#ff0000", + DependencyGraphEdgeKind.LibraryClause: "#000000", + DependencyGraphEdgeKind.UseClause: "#000000", + DependencyGraphEdgeKind.ContextReference: "#000000", + DependencyGraphEdgeKind.EntityImplementation: "#99ccff", + DependencyGraphEdgeKind.PackageImplementation: "#99ccff", + DependencyGraphEdgeKind.EntityInstantiation: "#000000", + DependencyGraphEdgeKind.ComponentInstantiation: "#000000", + DependencyGraphEdgeKind.ConfigurationInstantiation: "#000000", + } + + def __init__(self, graph: Graph): + self._graph = graph + + def WriteGraphML(self, path: Path): + print(path.absolute()) + with path.open("w") as file: + file.write( + dedent( + f"""\ + + + + + + + + + + """ + ) + ) + + for vertex in self._graph._verticesWithID.values(): + if vertex["kind"] is DependencyGraphVertexKind.Document: + file.write( + dedent( + """\ + {prefix} + {prefix} {vertex.ID} + {prefix} {vertex.Value.Path.name} + {prefix} {vertex[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", vertex=vertex, color=self.NODE_COLORS[vertex["kind"]]) + ) + + edgeCount = 1 + for edge in self._graph._edgesWithoutID: + file.write( + dedent( + """\ + {prefix} + {prefix} {edge[kind].name} + {prefix} {color} + {prefix} + """ + ).format(prefix=" ", edgeCount=edgeCount, edge=edge, color=self.EDGE_COLORS[edge["kind"]]) + ) + edgeCount += 1 + + file.write( + dedent( + """\ + + + """ + ) + ) diff --git a/pyGHDL/dom/formatting/prettyprint.py b/pyGHDL/dom/formatting/prettyprint.py index da26372c4..5be27492d 100644 --- a/pyGHDL/dom/formatting/prettyprint.py +++ b/pyGHDL/dom/formatting/prettyprint.py @@ -34,6 +34,15 @@ from typing import List, Union from pyTooling.Decorators import export +from pyVHDLModel.Base import NamedEntityMixin +from pyVHDLModel.Interface import GenericInterfaceItem, PortInterfaceItem +from pyVHDLModel.Subprogram import Function +from pyVHDLModel.Object import BaseConstant, WithDefaultExpressionMixin +from pyVHDLModel.Type import BaseType, FullType +from pyVHDLModel.Concurrent import ConcurrentStatement + +from pyGHDL import GHDLBaseException +from pyGHDL.dom.NonStandard import Document, Design, Library from pyGHDL.dom.Concurrent import ( ConcurrentBlockStatement, ProcessStatement, @@ -45,20 +54,6 @@ from pyGHDL.dom.Concurrent import ( EntityInstantiation, ConcurrentProcedureCall, ) -from pyVHDLModel.SyntaxModel import ( - GenericInterfaceItem, - NamedEntityMixin, - PortInterfaceItem, - WithDefaultExpressionMixin, - Function, - BaseType, - FullType, - BaseConstant, - ConcurrentStatement, -) - -from pyGHDL import GHDLBaseException -from pyGHDL.dom.NonStandard import Document, Design, Library from pyGHDL.dom.DesignUnit import ( Entity, Architecture, @@ -70,10 +65,7 @@ from pyGHDL.dom.DesignUnit import ( UseClause, PackageInstantiation, ) -from pyGHDL.dom.Symbol import ( - SimpleSubtypeSymbol, - ConstrainedCompositeSubtypeSymbol, -) +from pyGHDL.dom.Symbol import SimpleSubtypeSymbol, ConstrainedCompositeSubtypeSymbol from pyGHDL.dom.Type import ( IntegerType, Subtype, diff --git a/pyGHDL/dom/requirements.txt b/pyGHDL/dom/requirements.txt index 90c229354..ec127c98c 100644 --- a/pyGHDL/dom/requirements.txt +++ b/pyGHDL/dom/requirements.txt @@ -1,4 +1,4 @@ -r ../libghdl/requirements.txt -pyVHDLModel==0.20.2 +pyVHDLModel==0.22.1 #https://github.com/VHDL/pyVHDLModel/archive/dev.zip#pyVHDLModel diff --git a/pyGHDL/libghdl/requirements.txt b/pyGHDL/libghdl/requirements.txt index 5f5b740d6..9b79bd34d 100644 --- a/pyGHDL/libghdl/requirements.txt +++ b/pyGHDL/libghdl/requirements.txt @@ -1 +1 @@ -pyTooling>=2.1.0 +pyTooling>=2.11.0 -- cgit v1.2.3