truffle: graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java comparison

comparison graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java @ 18941:c943ba97b2a7

Remove class ScheduledNode from the node class hierarchy.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Sat, 24 Jan 2015 00:45:12 +0100
parents	498a56d8bb9b
children	bef8b6316627

comparison

equal deleted inserted replaced

-:2ad82c6147f1
+:c943ba97b2a7
 private NodeMap<Block> earliestCache;
 /**
 * Map from blocks to the nodes in each block.
 */
-private BlockMap<List<ScheduledNode>> blockToNodesMap;
+private BlockMap<List<ValueNode>> blockToNodesMap;
 private BlockMap<KillSet> blockToKillSet;
 private final SchedulingStrategy selectedStrategy;
 private final MemoryScheduling memsched;
 public SchedulePhase() {
 }
 /**
 * Gets the map from each block to the nodes in the block.
 */
-public BlockMap<List<ScheduledNode>> getBlockToNodesMap() {
+public BlockMap<List<ValueNode>> getBlockToNodesMap() {
 return blockToNodesMap;
 }
 /**
 * Gets the nodes in a given block.
 */
-public List<ScheduledNode> nodesFor(Block block) {
+public List<ValueNode> nodesFor(Block block) {
 return blockToNodesMap.get(block);
 }
 private void assignBlockToNodes(StructuredGraph graph, SchedulingStrategy strategy) {
 for (Block block : cfg.getBlocks()) {
-List<ScheduledNode> nodes = new ArrayList<>();
+List<ValueNode> nodes = new ArrayList<>();
 if (blockToNodesMap.get(block) != null) {
 throw new SchedulingError();
 }
 blockToNodesMap.put(block, nodes);
 for (FixedNode node : block.getNodes()) {
 nodes.add(node);
 }
 }
 for (Node n : graph.getNodes()) {
-if (n instanceof ScheduledNode) {
+if (n instanceof ValueNode) {
-assignBlockToNode((ScheduledNode) n, strategy);
+assignBlockToNode((ValueNode) n, strategy);
 }
 }
 }
 /**
 * Assigns a block to the given node. This method expects that PhiNodes and FixedNodes are
 * already assigned to a block.
 */
-private void assignBlockToNode(ScheduledNode node, SchedulingStrategy strategy) {
+private void assignBlockToNode(ValueNode node, SchedulingStrategy strategy) {
 assert !node.isDeleted();
 if (cfg.getNodeToBlock().containsKey(node)) {
 return;
 }
 * Calculates the last block that the given node could be scheduled in, i.e., the common
 * dominator of all usages. To do so all usages are also assigned to blocks.
 *
 * @param strategy
 */
-private Block latestBlock(ScheduledNode node, SchedulingStrategy strategy) {
+private Block latestBlock(ValueNode node, SchedulingStrategy strategy) {
 CommonDominatorBlockClosure cdbc = new CommonDominatorBlockClosure(null);
 for (Node succ : node.successors().nonNull()) {
 if (cfg.getNodeToBlock().get(succ) == null) {
 throw new SchedulingError();
 }
 *
 * @param node the node that needs to be scheduled
 * @param usage the usage whose blocks need to be considered
 * @param closure the closure that will be called for each block
 */
-private void blocksForUsage(ScheduledNode node, Node usage, BlockClosure closure, SchedulingStrategy strategy) {
+private void blocksForUsage(ValueNode node, Node usage, BlockClosure closure, SchedulingStrategy strategy) {
 if (node instanceof PhiNode) {
 throw new SchedulingError(node.toString());
 }
 if (usage instanceof PhiNode) {
 }
 if (!(unscheduledUsage instanceof NodeWithState)) {
 throw new SchedulingError(unscheduledUsage.toString());
 }
 // Otherwise: Put the input into the same block as the usage.
-assignBlockToNode((ScheduledNode) unscheduledUsage, strategy);
+assignBlockToNode((ValueNode) unscheduledUsage, strategy);
 closure.apply(cfg.getNodeToBlock().get(unscheduledUsage));
 }
 }
 } else {
 // All other types of usages: Put the input into the same block as the usage.
-assignBlockToNode((ScheduledNode) usage, strategy);
+assignBlockToNode((ValueNode) usage, strategy);
 closure.apply(cfg.getNodeToBlock().get(usage));
 }
 }
 private void ensureScheduledUsages(Node node, SchedulingStrategy strategy) {
-for (Node usage : node.usages().filter(ScheduledNode.class)) {
+for (Node usage : node.usages().filter(ValueNode.class)) {
-assignBlockToNode((ScheduledNode) usage, strategy);
+assignBlockToNode((ValueNode) usage, strategy);
 }
 // now true usages are ready
 }
 private void sortNodesWithinBlocks(StructuredGraph graph, SchedulingStrategy strategy) {
 assert noDuplicatedNodesInBlock(b) : "duplicated nodes in " + b;
 }
 }
 private boolean noDuplicatedNodesInBlock(Block b) {
-List<ScheduledNode> list = blockToNodesMap.get(b);
+List<ValueNode> list = blockToNodesMap.get(b);
-Set<ScheduledNode> hashset = Node.newSet(list);
+Set<ValueNode> hashset = Node.newSet(list);
 return list.size() == hashset.size();
 }
 private void sortNodesWithinBlock(Block b, NodeBitMap visited, NodeBitMap beforeLastLocation, SchedulingStrategy strategy) {
 if (visited.isMarked(b.getBeginNode()) || cfg.blockFor(b.getBeginNode()) != b) {
 }
 if (visited.isMarked(b.getEndNode()) || cfg.blockFor(b.getEndNode()) != b) {
 throw new SchedulingError();
 }
-List<ScheduledNode> sortedInstructions;
+List<ValueNode> sortedInstructions;
 switch (strategy) {
 case EARLIEST:
 sortedInstructions = sortNodesWithinBlockEarliest(b, visited);
 break;
 case LATEST:
 filterSchedulableNodes(blockToNodesMap.get(b)) + " vs. " + removeProxies(sortedInstructions);
 assert sameOrderForFixedNodes(blockToNodesMap.get(b), sortedInstructions) : "fixed nodes in sorted block are not in the same order";
 blockToNodesMap.put(b, sortedInstructions);
 }
-private static List<ScheduledNode> removeProxies(List<ScheduledNode> list) {
+private static List<ValueNode> removeProxies(List<ValueNode> list) {
-List<ScheduledNode> result = new ArrayList<>();
+List<ValueNode> result = new ArrayList<>();
-for (ScheduledNode n : list) {
+for (ValueNode n : list) {
 if (!(n instanceof ProxyNode)) {
 result.add(n);
 }
 }
 return result;
 }
-private static List<ScheduledNode> filterSchedulableNodes(List<ScheduledNode> list) {
+private static List<ValueNode> filterSchedulableNodes(List<ValueNode> list) {
-List<ScheduledNode> result = new ArrayList<>();
+List<ValueNode> result = new ArrayList<>();
-for (ScheduledNode n : list) {
+for (ValueNode n : list) {
 if (!(n instanceof PhiNode)) {
 result.add(n);
 }
 }
 return result;
 }
-private static boolean sameOrderForFixedNodes(List<ScheduledNode> fixed, List<ScheduledNode> sorted) {
+private static boolean sameOrderForFixedNodes(List<ValueNode> fixed, List<ValueNode> sorted) {
-Iterator<ScheduledNode> fixedIterator = fixed.iterator();
+Iterator<ValueNode> fixedIterator = fixed.iterator();
-Iterator<ScheduledNode> sortedIterator = sorted.iterator();
+Iterator<ValueNode> sortedIterator = sorted.iterator();
 while (sortedIterator.hasNext()) {
-ScheduledNode sortedCurrent = sortedIterator.next();
+ValueNode sortedCurrent = sortedIterator.next();
 if (sortedCurrent instanceof FixedNode) {
 if (!(fixedIterator.hasNext() && fixedIterator.next() == sortedCurrent)) {
 return false;
 }
 }
 private static class SortState {
 private Block block;
 private NodeBitMap visited;
 private NodeBitMap beforeLastLocation;
-private List<ScheduledNode> sortedInstructions;
+private List<ValueNode> sortedInstructions;
 private List<FloatingReadNode> reads;
-SortState(Block block, NodeBitMap visited, NodeBitMap beforeLastLocation, List<ScheduledNode> sortedInstructions) {
+SortState(Block block, NodeBitMap visited, NodeBitMap beforeLastLocation, List<ValueNode> sortedInstructions) {
 this.block = block;
 this.visited = visited;
 this.beforeLastLocation = beforeLastLocation;
 this.sortedInstructions = sortedInstructions;
 this.reads = null;
 return 0;
 }
 return reads.size();
 }
-void removeRead(ScheduledNode i) {
+void removeRead(ValueNode i) {
 assert reads != null;
 reads.remove(i);
 }
 List<FloatingReadNode> readsSnapshot() {
 assert reads != null;
 return new ArrayList<>(reads);
 }
-List<ScheduledNode> getSortedInstructions() {
+List<ValueNode> getSortedInstructions() {
 return sortedInstructions;
 }
-boolean containsInstruction(ScheduledNode i) {
+boolean containsInstruction(ValueNode i) {
 return sortedInstructions.contains(i);
 }
-void addInstruction(ScheduledNode i) {
+void addInstruction(ValueNode i) {
 sortedInstructions.add(i);
 }
 }
 /**
 * Sorts the nodes within a block by adding the nodes to a list in a post-order iteration over
 * all inputs. This means that a node is added to the list after all its inputs have been
 * processed.
 */
-private List<ScheduledNode> sortNodesWithinBlockLatest(Block b, NodeBitMap visited, NodeBitMap beforeLastLocation) {
+private List<ValueNode> sortNodesWithinBlockLatest(Block b, NodeBitMap visited, NodeBitMap beforeLastLocation) {
 SortState state = new SortState(b, visited, beforeLastLocation, new ArrayList<>(blockToNodesMap.get(b).size() + 2));
-List<ScheduledNode> instructions = blockToNodesMap.get(b);
+List<ValueNode> instructions = blockToNodesMap.get(b);
 if (memsched == MemoryScheduling.OPTIMAL) {
-for (ScheduledNode i : instructions) {
+for (ValueNode i : instructions) {
 if (i instanceof FloatingReadNode) {
 FloatingReadNode frn = (FloatingReadNode) i;
 if (!frn.location().getLocationIdentity().isImmutable()) {
 state.addRead(frn);
 if (nodesFor(b).contains(frn.getLastLocationAccess())) {
 }
 }
 }
 }
-for (ScheduledNode i : instructions) {
+for (ValueNode i : instructions) {
 addToLatestSorting(i, state);
 }
 assert state.readsSize() == 0 : "not all reads are scheduled";
 // Make sure that last node gets really last (i.e. when a frame state successor hangs off
 // it).
-List<ScheduledNode> sortedInstructions = state.getSortedInstructions();
+List<ValueNode> sortedInstructions = state.getSortedInstructions();
 Node lastSorted = sortedInstructions.get(sortedInstructions.size() - 1);
 if (lastSorted != b.getEndNode()) {
 int idx = sortedInstructions.indexOf(b.getEndNode());
 boolean canNotMove = false;
 for (int i = idx + 1; i < sortedInstructions.size(); i++) {
 for (Node input : state.inputs()) {
 if (input instanceof VirtualState) {
 addUnscheduledToLatestSorting((VirtualState) input, sortState);
 } else {
-addToLatestSorting((ScheduledNode) input, sortState);
+addToLatestSorting((ValueNode) input, sortState);
 }
 }
 }
 }
-private void addToLatestSorting(ScheduledNode i, SortState state) {
+private void addToLatestSorting(ValueNode i, SortState state) {
 if (i == null || state.isVisited(i) || cfg.getNodeToBlock().get(i) != state.currentBlock() || i instanceof PhiNode) {
 return;
 }
 FrameState stateAfter = null;
 if (input != stateAfter) {
 addUnscheduledToLatestSorting((FrameState) input, state);
 }
 } else {
 if (!(i instanceof ProxyNode && input instanceof LoopExitNode)) {
-addToLatestSorting((ScheduledNode) input, state);
+addToLatestSorting((ValueNode) input, state);
 }
 }
 }
 if (memsched == MemoryScheduling.OPTIMAL && state.readsSize() != 0) {
 }
 }
 assert MemoryCheckpoint.TypeAssertion.correctType(i);
 }
-addToLatestSorting((ScheduledNode) i.predecessor(), state);
+addToLatestSorting((ValueNode) i.predecessor(), state);
 state.markVisited(i);
 addUnscheduledToLatestSorting(stateAfter, state);
 // Now predecessors and inputs are scheduled => we can add this node.
 if (!state.containsInstruction(i)) {
 /**
 * Sorts the nodes within a block by adding the nodes to a list in a post-order iteration over
 * all usages. The resulting list is reversed to create an earliest-possible scheduling of
 * nodes.
 */
-private List<ScheduledNode> sortNodesWithinBlockEarliest(Block b, NodeBitMap visited) {
+private List<ValueNode> sortNodesWithinBlockEarliest(Block b, NodeBitMap visited) {
-List<ScheduledNode> sortedInstructions = new ArrayList<>(blockToNodesMap.get(b).size() + 2);
+List<ValueNode> sortedInstructions = new ArrayList<>(blockToNodesMap.get(b).size() + 2);
 addToEarliestSorting(b, b.getEndNode(), sortedInstructions, visited);
 Collections.reverse(sortedInstructions);
 return sortedInstructions;
 }
-private void addToEarliestSorting(Block b, ScheduledNode i, List<ScheduledNode> sortedInstructions, NodeBitMap visited) {
+private void addToEarliestSorting(Block b, ValueNode i, List<ValueNode> sortedInstructions, NodeBitMap visited) {
-ScheduledNode instruction = i;
+ValueNode instruction = i;
 while (true) {
 if (instruction == null || visited.isMarked(instruction) || cfg.getNodeToBlock().get(instruction) != b || instruction instanceof PhiNode) {
 return;
 }
 // only fixed nodes can have VirtualState -> no need to schedule them
 } else {
 if (instruction instanceof LoopExitNode && usage instanceof ProxyNode) {
 // value proxies should be scheduled before the loopexit, not after
 } else {
-addToEarliestSorting(b, (ScheduledNode) usage, sortedInstructions, visited);
+addToEarliestSorting(b, (ValueNode) usage, sortedInstructions, visited);
 }
 }
 }
 if (instruction instanceof BeginNode) {
 ArrayList<ProxyNode> proxies = (instruction instanceof LoopExitNode) ? new ArrayList<>() : null;
-for (ScheduledNode inBlock : blockToNodesMap.get(b)) {
+for (ValueNode inBlock : blockToNodesMap.get(b)) {
 if (!visited.isMarked(inBlock)) {
 if (inBlock instanceof ProxyNode) {
 proxies.add((ProxyNode) inBlock);
 } else {
 addToEarliestSorting(b, inBlock, sortedInstructions, visited);
 sortedInstructions.addAll(proxies);
 }
 break;
 } else {
 sortedInstructions.add(instruction);
-instruction = (ScheduledNode) instruction.predecessor();
+instruction = (ValueNode) instruction.predecessor();
 }
 }
 }
 }

Mercurial > hg > truffle

comparison graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java @ 18941:c943ba97b2a7