| /* |
| * Copyright (c) 2008, 2015, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| * |
| */ |
| package com.sun.hotspot.igv.data; |
| |
| import java.util.*; |
| |
| /** |
| * |
| * @author Thomas Wuerthinger |
| */ |
| public class InputGraph extends Properties.Entity implements FolderElement { |
| |
| private Map<Integer, InputNode> nodes; |
| private List<InputEdge> edges; |
| private Folder parent; |
| private Group parentGroup; |
| private Map<String, InputBlock> blocks; |
| private List<InputBlockEdge> blockEdges; |
| private Map<Integer, InputBlock> nodeToBlock; |
| |
| public InputGraph(String name) { |
| setName(name); |
| nodes = new LinkedHashMap<>(); |
| edges = new ArrayList<>(); |
| blocks = new LinkedHashMap<>(); |
| blockEdges = new ArrayList<>(); |
| nodeToBlock = new LinkedHashMap<>(); |
| } |
| |
| @Override |
| public void setParent(Folder parent) { |
| this.parent = parent; |
| if (parent instanceof Group) { |
| assert this.parentGroup == null; |
| this.parentGroup = (Group) parent; |
| } |
| } |
| |
| public InputBlockEdge addBlockEdge(InputBlock left, InputBlock right) { |
| InputBlockEdge edge = new InputBlockEdge(left, right); |
| blockEdges.add(edge); |
| left.addSuccessor(right); |
| return edge; |
| } |
| |
| public List<InputNode> findRootNodes() { |
| List<InputNode> result = new ArrayList<>(); |
| Set<Integer> nonRoot = new HashSet<>(); |
| for(InputEdge curEdges : getEdges()) { |
| nonRoot.add(curEdges.getTo()); |
| } |
| |
| for(InputNode node : getNodes()) { |
| if(!nonRoot.contains(node.getId())) { |
| result.add(node); |
| } |
| } |
| |
| return result; |
| } |
| |
| public Map<InputNode, List<InputEdge>> findAllOutgoingEdges() { |
| Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size()); |
| for(InputNode n : this.getNodes()) { |
| result.put(n, new ArrayList<InputEdge>()); |
| } |
| |
| for(InputEdge e : this.edges) { |
| int from = e.getFrom(); |
| InputNode fromNode = this.getNode(from); |
| List<InputEdge> fromList = result.get(fromNode); |
| assert fromList != null; |
| fromList.add(e); |
| } |
| |
| for(InputNode n : this.getNodes()) { |
| List<InputEdge> list = result.get(n); |
| Collections.sort(list, InputEdge.OUTGOING_COMPARATOR); |
| } |
| |
| return result; |
| } |
| |
| public Map<InputNode, List<InputEdge>> findAllIngoingEdges() { |
| Map<InputNode, List<InputEdge>> result = new HashMap<>(getNodes().size()); |
| for(InputNode n : this.getNodes()) { |
| result.put(n, new ArrayList<InputEdge>()); |
| } |
| |
| for(InputEdge e : this.edges) { |
| int to = e.getTo(); |
| InputNode toNode = this.getNode(to); |
| List<InputEdge> toList = result.get(toNode); |
| assert toList != null; |
| toList.add(e); |
| } |
| |
| for(InputNode n : this.getNodes()) { |
| List<InputEdge> list = result.get(n); |
| Collections.sort(list, InputEdge.INGOING_COMPARATOR); |
| } |
| |
| return result; |
| } |
| |
| public List<InputEdge> findOutgoingEdges(InputNode n) { |
| List<InputEdge> result = new ArrayList<>(); |
| |
| for(InputEdge e : this.edges) { |
| if(e.getFrom() == n.getId()) { |
| result.add(e); |
| } |
| } |
| |
| Collections.sort(result, InputEdge.OUTGOING_COMPARATOR); |
| |
| return result; |
| } |
| |
| public void clearBlocks() { |
| blocks.clear(); |
| nodeToBlock.clear(); |
| } |
| |
| public void setEdge(int fromIndex, int toIndex, int from, int to) { |
| assert fromIndex == ((char)fromIndex) : "Downcast must be safe"; |
| assert toIndex == ((char)toIndex) : "Downcast must be safe"; |
| |
| InputEdge edge = new InputEdge((char)fromIndex, (char)toIndex, from, to); |
| if(!this.getEdges().contains(edge)) { |
| this.addEdge(edge); |
| } |
| } |
| |
| public void ensureNodesInBlocks() { |
| InputBlock noBlock = null; |
| Set<InputNode> scheduledNodes = new HashSet<>(); |
| |
| for (InputBlock b : getBlocks()) { |
| for (InputNode n : b.getNodes()) { |
| assert !scheduledNodes.contains(n); |
| scheduledNodes.add(n); |
| } |
| } |
| |
| for (InputNode n : this.getNodes()) { |
| assert nodes.get(n.getId()) == n; |
| if (!scheduledNodes.contains(n)) { |
| if (noBlock == null) { |
| noBlock = this.addBlock("(no block)"); |
| } |
| noBlock.addNode(n.getId()); |
| } |
| assert this.getBlock(n) != null; |
| } |
| } |
| |
| public void setBlock(InputNode node, InputBlock block) { |
| nodeToBlock.put(node.getId(), block); |
| } |
| |
| public InputBlock getBlock(int nodeId) { |
| return nodeToBlock.get(nodeId); |
| } |
| |
| public InputBlock getBlock(InputNode node) { |
| assert nodes.containsKey(node.getId()); |
| assert nodes.get(node.getId()).equals(node); |
| return getBlock(node.getId()); |
| } |
| |
| public InputGraph getNext() { |
| return parentGroup.getNext(this); |
| } |
| |
| public InputGraph getPrev() { |
| return parentGroup.getPrev(this); |
| } |
| |
| private void setName(String name) { |
| this.getProperties().setProperty("name", name); |
| } |
| |
| @Override |
| public String getName() { |
| return getProperties().get("name"); |
| } |
| |
| public Collection<InputNode> getNodes() { |
| return Collections.unmodifiableCollection(nodes.values()); |
| } |
| |
| public Set<Integer> getNodesAsSet() { |
| return Collections.unmodifiableSet(nodes.keySet()); |
| } |
| |
| public Collection<InputBlock> getBlocks() { |
| return Collections.unmodifiableCollection(blocks.values()); |
| } |
| |
| public void addNode(InputNode node) { |
| nodes.put(node.getId(), node); |
| } |
| |
| public InputNode getNode(int id) { |
| return nodes.get(id); |
| } |
| |
| public InputNode removeNode(int index) { |
| return nodes.remove(index); |
| } |
| |
| public Collection<InputEdge> getEdges() { |
| return Collections.unmodifiableList(edges); |
| } |
| |
| public void removeEdge(InputEdge c) { |
| boolean removed = edges.remove(c); |
| assert removed; |
| } |
| |
| public void addEdge(InputEdge c) { |
| edges.add(c); |
| } |
| |
| public Group getGroup() { |
| return parentGroup; |
| } |
| |
| @Override |
| public String toString() { |
| StringBuilder sb = new StringBuilder(); |
| sb.append("Graph ").append(getName()).append(" ").append(getProperties().toString()).append("\n"); |
| for (InputNode n : nodes.values()) { |
| sb.append(n.toString()); |
| sb.append("\n"); |
| } |
| |
| for (InputEdge c : edges) { |
| sb.append(c.toString()); |
| sb.append("\n"); |
| } |
| |
| for (InputBlock b : getBlocks()) { |
| sb.append(b.toString()); |
| sb.append("\n"); |
| } |
| |
| return sb.toString(); |
| } |
| |
| public InputBlock addBlock(String name) { |
| final InputBlock b = new InputBlock(this, name); |
| blocks.put(b.getName(), b); |
| return b; |
| } |
| |
| public InputBlock getBlock(String s) { |
| return blocks.get(s); |
| } |
| |
| public Collection<InputBlockEdge> getBlockEdges() { |
| return Collections.unmodifiableList(blockEdges); |
| } |
| |
| @Override |
| public Folder getParent() { |
| return parent; |
| } |
| } |