5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.phases.schedule;
  24 








  25 import org.graalvm.compiler.core.common.GraalOptions;
  26 import org.graalvm.compiler.core.common.SuppressFBWarnings;
  27 import org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph;
  28 import org.graalvm.compiler.core.common.cfg.BlockMap;
  29 import org.graalvm.compiler.debug.Assertions;
  30 import org.graalvm.compiler.debug.Debug;
  31 import org.graalvm.compiler.graph.Graph.NodeEvent;
  32 import org.graalvm.compiler.graph.Graph.NodeEventListener;
  33 import org.graalvm.compiler.graph.Graph.NodeEventScope;
  34 import org.graalvm.compiler.graph.Node;
  35 import org.graalvm.compiler.graph.NodeBitMap;
  36 import org.graalvm.compiler.graph.NodeMap;
  37 import org.graalvm.compiler.graph.NodeStack;
  38 import org.graalvm.compiler.nodes.AbstractBeginNode;
  39 import org.graalvm.compiler.nodes.AbstractEndNode;
  40 import org.graalvm.compiler.nodes.AbstractMergeNode;
  41 import org.graalvm.compiler.nodes.ControlSinkNode;
  42 import org.graalvm.compiler.nodes.ControlSplitNode;
  43 import org.graalvm.compiler.nodes.DeoptimizeNode;
  44 import org.graalvm.compiler.nodes.FixedNode;
  45 import org.graalvm.compiler.nodes.FixedWithNextNode;
  46 import org.graalvm.compiler.nodes.GuardNode;
  47 import org.graalvm.compiler.nodes.IfNode;
  48 import org.graalvm.compiler.nodes.KillingBeginNode;
  49 import org.graalvm.compiler.nodes.LoopBeginNode;
  50 import org.graalvm.compiler.nodes.LoopExitNode;

  52 import org.graalvm.compiler.nodes.ProxyNode;
  53 import org.graalvm.compiler.nodes.StartNode;
  54 import org.graalvm.compiler.nodes.StructuredGraph;
  55 import org.graalvm.compiler.nodes.StructuredGraph.GuardsStage;
  56 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
  57 import org.graalvm.compiler.nodes.ValueNode;
  58 import org.graalvm.compiler.nodes.VirtualState;
  59 import org.graalvm.compiler.nodes.calc.ConvertNode;
  60 import org.graalvm.compiler.nodes.calc.IsNullNode;
  61 import org.graalvm.compiler.nodes.cfg.Block;
  62 import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
  63 import org.graalvm.compiler.nodes.cfg.HIRLoop;
  64 import org.graalvm.compiler.nodes.cfg.LocationSet;
  65 import org.graalvm.compiler.nodes.memory.FloatingReadNode;
  66 import org.graalvm.compiler.nodes.memory.MemoryCheckpoint;
  67 import org.graalvm.compiler.nodes.spi.ValueProxy;
  68 import org.graalvm.compiler.options.OptionValues;
  69 import org.graalvm.compiler.phases.Phase;
  70 import org.graalvm.word.LocationIdentity;
  71 
  72 import java.util.ArrayList;
  73 import java.util.Arrays;
  74 import java.util.Formatter;
  75 import java.util.List;
  76 
  77 import static org.graalvm.compiler.core.common.GraalOptions.OptScheduleOutOfLoops;
  78 import static org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph.strictlyDominates;
  79 
  80 public final class SchedulePhase extends Phase {
  81 
  82     public enum SchedulingStrategy {
  83         EARLIEST,
  84         LATEST,
  85         LATEST_OUT_OF_LOOPS,
  86         FINAL_SCHEDULE
  87     }
  88 
  89     private final SchedulingStrategy selectedStrategy;
  90 
  91     private final boolean immutableGraph;
  92 
  93     public SchedulePhase(OptionValues options) {
  94         this(false, options);
  95     }
  96 
  97     public SchedulePhase(boolean immutableGraph, OptionValues options) {
  98         this(OptScheduleOutOfLoops.getValue(options) ? SchedulingStrategy.LATEST_OUT_OF_LOOPS : SchedulingStrategy.LATEST, immutableGraph);
  99     }

 997         }
 998 
 999         private static void printNode(Node n) {
1000             Formatter buf = new Formatter();
1001             buf.format("%s", n);
1002             if (n instanceof MemoryCheckpoint.Single) {
1003                 buf.format(" // kills %s", ((MemoryCheckpoint.Single) n).getLocationIdentity());
1004             } else if (n instanceof MemoryCheckpoint.Multi) {
1005                 buf.format(" // kills ");
1006                 for (LocationIdentity locid : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) {
1007                     buf.format("%s, ", locid);
1008                 }
1009             } else if (n instanceof FloatingReadNode) {
1010                 FloatingReadNode frn = (FloatingReadNode) n;
1011                 buf.format(" // from %s", frn.getLocationIdentity());
1012                 buf.format(", lastAccess: %s", frn.getLastLocationAccess());
1013                 buf.format(", address: %s", frn.getAddress());
1014             } else if (n instanceof GuardNode) {
1015                 buf.format(", anchor: %s", ((GuardNode) n).getAnchor());
1016             }
1017             Debug.log("%s", buf);
1018         }
1019 
1020         public ControlFlowGraph getCFG() {
1021             return cfg;
1022         }
1023 
1024         /**
1025          * Gets the nodes in a given block.
1026          */
1027         public List<Node> nodesFor(Block block) {
1028             return blockToNodesMap.get(block);
1029         }
1030     }
1031 
1032 }

   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 package org.graalvm.compiler.phases.schedule;
  24 
  25 import static org.graalvm.compiler.core.common.GraalOptions.OptScheduleOutOfLoops;
  26 import static org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph.strictlyDominates;
  27 
  28 import java.util.ArrayList;
  29 import java.util.Arrays;
  30 import java.util.Formatter;
  31 import java.util.List;
  32 
  33 import org.graalvm.compiler.core.common.GraalOptions;
  34 import org.graalvm.compiler.core.common.SuppressFBWarnings;
  35 import org.graalvm.compiler.core.common.cfg.AbstractControlFlowGraph;
  36 import org.graalvm.compiler.core.common.cfg.BlockMap;
  37 import org.graalvm.compiler.debug.Assertions;

  38 import org.graalvm.compiler.graph.Graph.NodeEvent;
  39 import org.graalvm.compiler.graph.Graph.NodeEventListener;
  40 import org.graalvm.compiler.graph.Graph.NodeEventScope;
  41 import org.graalvm.compiler.graph.Node;
  42 import org.graalvm.compiler.graph.NodeBitMap;
  43 import org.graalvm.compiler.graph.NodeMap;
  44 import org.graalvm.compiler.graph.NodeStack;
  45 import org.graalvm.compiler.nodes.AbstractBeginNode;
  46 import org.graalvm.compiler.nodes.AbstractEndNode;
  47 import org.graalvm.compiler.nodes.AbstractMergeNode;
  48 import org.graalvm.compiler.nodes.ControlSinkNode;
  49 import org.graalvm.compiler.nodes.ControlSplitNode;
  50 import org.graalvm.compiler.nodes.DeoptimizeNode;
  51 import org.graalvm.compiler.nodes.FixedNode;
  52 import org.graalvm.compiler.nodes.FixedWithNextNode;
  53 import org.graalvm.compiler.nodes.GuardNode;
  54 import org.graalvm.compiler.nodes.IfNode;
  55 import org.graalvm.compiler.nodes.KillingBeginNode;
  56 import org.graalvm.compiler.nodes.LoopBeginNode;
  57 import org.graalvm.compiler.nodes.LoopExitNode;

  59 import org.graalvm.compiler.nodes.ProxyNode;
  60 import org.graalvm.compiler.nodes.StartNode;
  61 import org.graalvm.compiler.nodes.StructuredGraph;
  62 import org.graalvm.compiler.nodes.StructuredGraph.GuardsStage;
  63 import org.graalvm.compiler.nodes.StructuredGraph.ScheduleResult;
  64 import org.graalvm.compiler.nodes.ValueNode;
  65 import org.graalvm.compiler.nodes.VirtualState;
  66 import org.graalvm.compiler.nodes.calc.ConvertNode;
  67 import org.graalvm.compiler.nodes.calc.IsNullNode;
  68 import org.graalvm.compiler.nodes.cfg.Block;
  69 import org.graalvm.compiler.nodes.cfg.ControlFlowGraph;
  70 import org.graalvm.compiler.nodes.cfg.HIRLoop;
  71 import org.graalvm.compiler.nodes.cfg.LocationSet;
  72 import org.graalvm.compiler.nodes.memory.FloatingReadNode;
  73 import org.graalvm.compiler.nodes.memory.MemoryCheckpoint;
  74 import org.graalvm.compiler.nodes.spi.ValueProxy;
  75 import org.graalvm.compiler.options.OptionValues;
  76 import org.graalvm.compiler.phases.Phase;
  77 import org.graalvm.word.LocationIdentity;
  78 








  79 public final class SchedulePhase extends Phase {
  80 
  81     public enum SchedulingStrategy {
  82         EARLIEST,
  83         LATEST,
  84         LATEST_OUT_OF_LOOPS,
  85         FINAL_SCHEDULE
  86     }
  87 
  88     private final SchedulingStrategy selectedStrategy;
  89 
  90     private final boolean immutableGraph;
  91 
  92     public SchedulePhase(OptionValues options) {
  93         this(false, options);
  94     }
  95 
  96     public SchedulePhase(boolean immutableGraph, OptionValues options) {
  97         this(OptScheduleOutOfLoops.getValue(options) ? SchedulingStrategy.LATEST_OUT_OF_LOOPS : SchedulingStrategy.LATEST, immutableGraph);
  98     }

 996         }
 997 
 998         private static void printNode(Node n) {
 999             Formatter buf = new Formatter();
1000             buf.format("%s", n);
1001             if (n instanceof MemoryCheckpoint.Single) {
1002                 buf.format(" // kills %s", ((MemoryCheckpoint.Single) n).getLocationIdentity());
1003             } else if (n instanceof MemoryCheckpoint.Multi) {
1004                 buf.format(" // kills ");
1005                 for (LocationIdentity locid : ((MemoryCheckpoint.Multi) n).getLocationIdentities()) {
1006                     buf.format("%s, ", locid);
1007                 }
1008             } else if (n instanceof FloatingReadNode) {
1009                 FloatingReadNode frn = (FloatingReadNode) n;
1010                 buf.format(" // from %s", frn.getLocationIdentity());
1011                 buf.format(", lastAccess: %s", frn.getLastLocationAccess());
1012                 buf.format(", address: %s", frn.getAddress());
1013             } else if (n instanceof GuardNode) {
1014                 buf.format(", anchor: %s", ((GuardNode) n).getAnchor());
1015             }
1016             n.getDebug().log("%s", buf);
1017         }
1018 
1019         public ControlFlowGraph getCFG() {
1020             return cfg;
1021         }
1022 
1023         /**
1024          * Gets the nodes in a given block.
1025          */
1026         public List<Node> nodesFor(Block block) {
1027             return blockToNodesMap.get(block);
1028         }
1029     }
1030 
1031 }