graal-jvmci-8: 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 @ 19564:f53c6c8e2048

Refactorings in SchedulePhase.

author	Thomas Wuerthinger <thomas.wuerthinger@oracle.com>
date	Mon, 23 Feb 2015 17:57:58 +0100
parents	fcefaa7f103d
children	08d94d9f0b0f

comparison

equal deleted inserted replaced

-:fb32f2d8abf4
+:f53c6c8e2048
 }
 earliest = earliestCache.get(node);
 if (earliest != null) {
 return earliest;
 }
+return earliestBlockHelper(node, earliest);
+}
+private Block earliestBlockHelper(Node node, Block earliest) throws SchedulingError {
 /*
 * All inputs must be in a dominating block, otherwise the graph cannot be scheduled. This
 * implies that the inputs' blocks have a total ordering via their dominance relation. So in
 * order to find the earliest block placement for this node we need to find the input block
 * that is dominated by all other input blocks.
 */
 if (node.predecessor() != null) {
 throw new SchedulingError();
 }
-for (Node input : node.inputs().nonNull()) {
+for (Node input : node.inputs()) {
-assert input instanceof ValueNode;
+if (input != null) {
-Block inputEarliest;
+assert input instanceof ValueNode;
-if (input instanceof InvokeWithExceptionNode) {
+Block inputEarliest;
-inputEarliest = cfg.getNodeToBlock().get(((InvokeWithExceptionNode) input).next());
+if (input instanceof InvokeWithExceptionNode) {
-} else {
+inputEarliest = cfg.getNodeToBlock().get(((InvokeWithExceptionNode) input).next());
-inputEarliest = earliestBlock(input);
+} else {
-}
+inputEarliest = earliestBlock(input);
-if (earliest == null) {
+}
-earliest = inputEarliest;
+if (earliest == null) {
-} else if (earliest != inputEarliest) {
+earliest = inputEarliest;
-// Find out whether earliest or inputEarliest is earlier.
+} else if (earliest != inputEarliest) {
-Block a = earliest.getDominator();
+earliest = findEarlierBlock(earliest, inputEarliest);
-Block b = inputEarliest;
-while (true) {
-if (a == inputEarliest || b == null) {
-// Nothing to change, the previous earliest block is still earliest.
-break;
-} else if (b == earliest || a == null) {
-// New earliest is the earliest.
-earliest = inputEarliest;
-break;
-}
-a = a.getDominator();
-b = b.getDominator();
 }
 }
 }
 if (earliest == null) {
 earliest = cfg.getStartBlock();
 }
 earliestCache.set(node, earliest);
 return earliest;
+}
+private static Block findEarlierBlock(Block earliest, Block inputEarliest) {
+// Find out whether earliest or inputEarliest is earlier.
+Block a = earliest.getDominator();
+Block b = inputEarliest;
+while (true) {
+if (a == inputEarliest || b == null) {
+// Nothing to change, the previous earliest block is still earliest.
+return earliest;
+} else if (b == earliest || a == null) {
+// New earliest is the earliest.
+return inputEarliest;
+}
+a = a.getDominator();
+b = b.getDominator();
+}
 }
 /**
 * Schedules a node out of loop based on its earliest schedule. Note that this movement is only
 * valid if it's done for <b>every</b> other node in the schedule, otherwise this movement is
 ProxyNode proxyNode = (ProxyNode) i;
 addToLatestSorting(proxyNode.value(), state);
 return;
 }
+addToLatestSortingHelper(i, state);
+}
+private void addToLatestSortingHelper(ValueNode i, SortState state) {
 FrameState stateAfter = null;
 if (i instanceof StateSplit) {
 stateAfter = ((StateSplit) i).stateAfter();
 }
-for (Node input : i.inputs()) {
+addInputsToLatestSorting(i, state, stateAfter);
-if (input instanceof FrameState) {
-if (input != stateAfter) {
-addUnscheduledToLatestSorting((FrameState) input, state);
-}
-} else {
-addToLatestSorting((ValueNode) input, state);
-}
-}
 if (state.readsSize() != 0) {
 if (i instanceof MemoryCheckpoint.Single) {
 LocationIdentity identity = ((MemoryCheckpoint.Single) i).getLocationIdentity();
 processKillLocation(i, identity, state);
 if (state.readsSize() != 0 && i instanceof FloatingReadNode) {
 state.removeRead(i);
 }
 }
+private void addInputsToLatestSorting(ValueNode i, SortState state, FrameState stateAfter) {
+for (Node input : i.inputs()) {
+if (input instanceof FrameState) {
+if (input != stateAfter) {
+addUnscheduledToLatestSorting((FrameState) input, state);
+}
+} else {
+addToLatestSorting((ValueNode) input, state);
+}
+}
+}
 /**
 * 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.
 */

Mercurial > hg > graal-jvmci-8

comparison graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java @ 19564:f53c6c8e2048