--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/GraalOptions.java	Fri Jul 26 20:18:42 2013 +0200
+++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/GraalOptions.java	Fri Jul 26 20:18:42 2013 +0200
@@ -235,6 +235,8 @@
 
     @Option(help = "")
     public static final OptionValue<Boolean> MemoryAwareScheduling = new OptionValue<>(true);
+    @Option(help = "")
+    public static final OptionValue<Boolean> NewMemoryAwareScheduling = new OptionValue<>(false);
 
     // Translating tableswitch instructions
     @Option(help = "")

--- a/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java	Fri Jul 26 20:18:42 2013 +0200
+++ b/graal/com.oracle.graal.phases/src/com/oracle/graal/phases/schedule/SchedulePhase.java	Fri Jul 26 20:18:42 2013 +0200
@@ -72,6 +72,10 @@
         EARLIEST, LATEST, LATEST_OUT_OF_LOOPS
     }
 
+    public static enum MemoryScheduling {
+        NONE, CONSERVATIVE, OPTIMAL
+    }
+
     /**
      * This closure iterates over all nodes of a scheduled graph (it expects a
      * {@link SchedulingStrategy#EARLIEST} schedule) and keeps a list of "active" reads. Whenever it
@@ -178,6 +182,7 @@
     private BlockMap<List<ScheduledNode>> blockToNodesMap;
     private final Map<FloatingNode, List<FixedNode>> phantomUsages = new IdentityHashMap<>();
     private final Map<FixedNode, List<FloatingNode>> phantomInputs = new IdentityHashMap<>();
+    private final MemoryScheduling memsched;
     private final SchedulingStrategy selectedStrategy;
 
     public SchedulePhase() {
@@ -185,17 +190,31 @@
     }
 
     public SchedulePhase(SchedulingStrategy strategy) {
+        if (MemoryAwareScheduling.getValue() && NewMemoryAwareScheduling.getValue()) {
+            throw new SchedulingError("cannot enable both: MemoryAware- and NewMemoryAwareScheduling");
+        }
+        if (MemoryAwareScheduling.getValue()) {
+            this.memsched = MemoryScheduling.CONSERVATIVE;
+        } else if (NewMemoryAwareScheduling.getValue()) {
+            this.memsched = MemoryScheduling.OPTIMAL;
+        } else {
+            this.memsched = MemoryScheduling.NONE;
+        }
         this.selectedStrategy = strategy;
     }
 
+    public SchedulePhase(SchedulingStrategy strategy, MemoryScheduling memsched) {
+        this.selectedStrategy = strategy;
+        this.memsched = memsched;
+    }
+
     @Override
     protected void run(StructuredGraph graph) {
         cfg = ControlFlowGraph.compute(graph, true, true, true, true);
         earliestCache = graph.createNodeMap();
         blockToNodesMap = new BlockMap<>(cfg);
 
-        if (MemoryAwareScheduling.getValue() && selectedStrategy != SchedulingStrategy.EARLIEST && graph.getNodes(FloatingReadNode.class).isNotEmpty()) {
-
+        if (memsched == MemoryScheduling.CONSERVATIVE && selectedStrategy != SchedulingStrategy.EARLIEST && graph.getNodes(FloatingReadNode.class).isNotEmpty()) {
             assignBlockToNodes(graph, SchedulingStrategy.EARLIEST);
             sortNodesWithinBlocks(graph, SchedulingStrategy.EARLIEST);
 
@@ -204,10 +223,15 @@
 
             cfg.clearNodeToBlock();
             blockToNodesMap = new BlockMap<>(cfg);
+
+            assignBlockToNodes(graph, selectedStrategy);
+            sortNodesWithinBlocks(graph, selectedStrategy);
+        } else if (memsched == MemoryScheduling.OPTIMAL && selectedStrategy != SchedulingStrategy.EARLIEST && graph.getNodes(FloatingReadNode.class).isNotEmpty()) {
+            // TODO
+        } else {
+            assignBlockToNodes(graph, selectedStrategy);
+            sortNodesWithinBlocks(graph, selectedStrategy);
         }
-
-        assignBlockToNodes(graph, selectedStrategy);
-        sortNodesWithinBlocks(graph, selectedStrategy);
     }
 
     public ControlFlowGraph getCFG() {