diff --git a/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java b/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java index 44cf225..40caf08 100644 --- a/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java +++ b/AlgebraicDataflowArchitectureModel/src/generators/CodeGenerator.java @@ -27,6 +27,7 @@ import models.algebra.Term; import models.algebra.Type; import models.algebra.Variable; +import models.controlFlowModel.StatefulObjectNode; import models.dataConstraintModel.Channel; import models.dataConstraintModel.ChannelMember; import models.dataConstraintModel.DataConstraintModel; @@ -144,7 +145,7 @@ ArrayList codes = new ArrayList<>(); Map> dependedRootComponentGraph = null; - Collection components = null; + Collection> components = null; if (platformSpec.isMonolithic()) { // To build monolithic application, the dependency of the components should be resolved in advance. @@ -155,7 +156,7 @@ components = determineComponentOrder(flowGraph, dependedRootComponentGraph); } else { // Get the all components. - components = flowGraph.getResourceNodes(); + components = flowGraph.getAllComponentNodes().values(); } // Generate the other components. @@ -164,25 +165,25 @@ return codes; } - public abstract void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection components, ArrayList codes, + public abstract void generateCodeFromFlowGraph(DataTransferModel model, IFlowGraph flowGraph, Collection> components, ArrayList codes, Map> dependedRootComponentGraph, IPlatformSpecific platformSpec, ILanguageSpecific langSpec); private static Map> getDependedRootComponentGraph(DataTransferModel model) { Map> dependedComponentGraph = new HashMap<>(); for (Channel ch: model.getChannels()) { - Set inRes = new HashSet<>(); - Set outRes = new HashSet<>(); - getDependedRootComponentGraphSub(ch, inRes, outRes, true); - if (outRes.size() > 0 && inRes.size() > 0) { - for (ResourceHierarchy out: outRes) { - for (ResourceHierarchy in: inRes) { - Set dependings = dependedComponentGraph.get(out.getRoot()); + Set insideRes = new HashSet<>(); + Set outsideRes = new HashSet<>(); + getDependedRootComponentGraphSub(ch, insideRes, outsideRes, true); + if (outsideRes.size() > 0 && insideRes.size() > 0) { + for (ResourceHierarchy outside: outsideRes) { + for (ResourceHierarchy inside: insideRes) { + Set dependings = dependedComponentGraph.get(outside.getRoot()); if (dependings == null) { dependings = new HashSet<>(); - dependedComponentGraph.put(out.getRoot(), dependings); + dependedComponentGraph.put(outside.getRoot(), dependings); } - if (!out.getRoot().equals(in.getRoot())) { - dependings.add(in.getRoot()); + if (!outside.getRoot().equals(inside.getRoot())) { + dependings.add(inside.getRoot()); } } } @@ -191,75 +192,85 @@ return dependedComponentGraph; } - private static void getDependedRootComponentGraphSub(Channel ch, Set inRes, Set outRes, boolean isRoot) { + private static void getDependedRootComponentGraphSub(Channel ch, Set insideRes, Set outsideRes, boolean isRoot) { DataTransferChannel dtCh = (DataTransferChannel) ch; for (ChannelMember cm: dtCh.getChannelMembers()) { if (!isRoot && !cm.isOutside()) { - outRes.add(cm.getResource().getResourceHierarchy()); // dependency to a descendant channel resource. + outsideRes.add(cm.getResource().getResourceHierarchy()); // dependency to a descendant channel resource. } if (cm.isOutside()) { - outRes.add(cm.getResource().getResourceHierarchy()); // dependency to an outside resource. + outsideRes.add(cm.getResource().getResourceHierarchy()); // dependency to an outside resource. } else { - inRes.add(cm.getResource().getResourceHierarchy()); // dependency from an inside resource. + insideRes.add(cm.getResource().getResourceHierarchy()); // dependency from an inside resource. } } for (Channel childCh: ch.getChildren()) { - getDependedRootComponentGraphSub(childCh, inRes, outRes, false); + getDependedRootComponentGraphSub(childCh, insideRes, outsideRes, false); } } - private static ArrayList determineComponentOrder(IFlowGraph graph, Map> dependedRootComponentGraph) { - ArrayList objects = new ArrayList<>(); - Set visited = new HashSet<>(); - Collection allNodes = graph.getResourceNodes(); - for (ResourceNode resNode: allNodes) { - topologicalSort(resNode, allNodes, dependedRootComponentGraph, visited, objects); + private static ArrayList> determineComponentOrder(IFlowGraph graph, Map> dependedRootComponentGraph) { + ArrayList> objectList = new ArrayList<>(); + Set> visited = new HashSet<>(); + Map> allNodes = graph.getAllComponentNodes(); + for (Set nodeSet: allNodes.values()) { + topologicalSort(nodeSet, allNodes, dependedRootComponentGraph, visited, objectList); } - return objects; + return objectList; } - private static void topologicalSort(ResourceNode curResNode, Collection allNodes, Map> dependedRootComponentGraph, Set visited, List orderedList) { - if (visited.contains(curResNode)) return; - visited.add(curResNode); + private static void topologicalSort(Set curNodeSet, Map> allNodeSets, Map> dependedRootComponentGraph, Set> visited, List> orderedList) { + if (visited.contains(curNodeSet)) return; + visited.add(curNodeSet); // A caller is before the callee // For each incoming PUSH transfer. - for (Edge chToRes: curResNode.getInEdges()) { - for (Edge resToCh: chToRes.getSource().getInEdges()) { - if (!(resToCh instanceof DataFlowEdge) || ((PushPullAttribute)((DataFlowEdge) resToCh).getAttribute()).getSelectedOption() == PushPullValue.PUSH) { - topologicalSort((ResourceNode) resToCh.getSource(), allNodes, dependedRootComponentGraph, visited, orderedList); + for (Node curNode: curNodeSet) { + for (Edge chToRes: curNode.getInEdges()) { + for (Edge resToCh: chToRes.getSource().getInEdges()) { + if (!(resToCh instanceof DataFlowEdge) || ((PushPullAttribute)((DataFlowEdge) resToCh).getAttribute()).getSelectedOption() == PushPullValue.PUSH) { + topologicalSort(allNodeSets.get(resToCh.getSource()), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } // For each outgoing PULL transfer. - if (curResNode instanceof ResourceNode) { - for (Edge resToCh: curResNode.getOutEdges()) { - DataFlowEdge de = (DataFlowEdge) resToCh; - if (((PushPullAttribute) de.getAttribute()).getSelectedOption() != PushPullValue.PUSH) { - for (Edge chToRes : resToCh.getDestination().getOutEdges()) { - topologicalSort((ResourceNode) chToRes.getDestination(), allNodes, dependedRootComponentGraph, visited, orderedList); + if (curNodeSet.iterator().next() instanceof ResourceNode) { + for (Node curNode: curNodeSet) { + for (Edge resToCh: curNode.getOutEdges()) { + DataFlowEdge de = (DataFlowEdge) resToCh; + if (((PushPullAttribute) de.getAttribute()).getSelectedOption() != PushPullValue.PUSH) { + for (Edge chToRes : resToCh.getDestination().getOutEdges()) { + topologicalSort(allNodeSets.get(chToRes.getDestination()), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } } // For each depending root node. - if (curResNode instanceof ResourceNode && dependedRootComponentGraph.get(curResNode.getResourceHierarchy()) != null) { - for (ResourceHierarchy dependingRes: dependedRootComponentGraph.get(curResNode.getResourceHierarchy())) { - for (ResourceNode rootNode: allNodes) { - ResourceHierarchy rootRes = rootNode.getResourceHierarchy(); - if (rootRes.getParent() == null && rootRes.equals(dependingRes)) { - topologicalSort(rootNode, allNodes, dependedRootComponentGraph, visited, orderedList); + Node curNode = curNodeSet.iterator().next(); + if (curNode instanceof ResourceNode && dependedRootComponentGraph.get(((ResourceNode) curNode).getResourceHierarchy()) != null) { + for (ResourceHierarchy dependingRes: dependedRootComponentGraph.get(((ResourceNode) curNode).getResourceHierarchy())) { + for (Node node: allNodeSets.keySet()) { + if (node instanceof ResourceNode) { + ResourceNode rootNode = (ResourceNode) node; + ResourceHierarchy rootRes = rootNode.getResourceHierarchy(); + if (rootRes.getParent() == null && rootRes.equals(dependingRes)) { + topologicalSort(allNodeSets.get(rootNode), allNodeSets, dependedRootComponentGraph, visited, orderedList); + } } } } } // For each reference resource. ResourceNode cn = null; - if (curResNode instanceof ResourceNode) { - cn = (ResourceNode) curResNode; + if (curNode instanceof ResourceNode) { + cn = (ResourceNode) curNode; + } else if (curNode instanceof StatefulObjectNode) { + cn = ((StatefulObjectNode) curNode).getResource(); } if (cn != null) { - for (Node n: allNodes) { + for (Node n: allNodeSets.keySet()) { ResourceNode resNode = null; if (n instanceof ResourceNode) { resNode = (ResourceNode) n; @@ -268,15 +279,15 @@ for (Edge resToCh: resNode.getOutEdges()) { ChannelNode chNode = (ChannelNode) resToCh.getDestination(); for (ChannelMember m: chNode.getChannel().getReferenceChannelMembers()) { - if (curResNode.getOutSideResources().contains(m.getResource())) { - topologicalSort(resNode, allNodes, dependedRootComponentGraph, visited, orderedList); + if (cn.getOutSideResources().contains(m.getResource())) { + topologicalSort(allNodeSets.get(resNode), allNodeSets, dependedRootComponentGraph, visited, orderedList); } } } } } } - orderedList.add(0, curResNode); + orderedList.add(0, curNodeSet); } protected void updateMainComponent(TypeDeclaration mainType, MethodDeclaration mainConstructor, Node componentNode,