cfg: inline from back to front

Intuitively, it makes sense to inline back to front:

* Suppose we are able to inline line i into line i+1. After that inline
  operation, we may now be able to inline line i-1 into line i+1. So we
  should check that next. This implies we should move backward in the
  program rather than moving forward.

* Will we lose anything by moving backward? Well, suppose we were able
  to inline line i into line i+1. Could that possibly have impacted the
  ability to inline line i+1 into line i+2? No. Thus, it is not possible
  that going backwards results in more passes over the program than
  going forward.

The only trick to implementation was that when sliding the window
forward, we need to remember line i+1 in the case of a successful
inline.

This is anecdotal, but for the attached chained.myl example, the time to
produce the logical plan was reduced for me from .58 seconds to .26.

examples/chained.myl

@@ -0,0 +1,107 @@
+data = empty(x:int, y:int);
+data1 = data;
+data2 = [from data, data1 emit data.*];
+data4 = [from data2, data2 as data emit data.*];
+data8 = [from data4, data4 as data emit data.*];
+data16 = [from data8, data8 as data emit data.*];
+
+out = [from data16 emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+out = [from out emit $0];
+
+store(out, OUTPUT);

raco/myrial/cfg.py

@@ -197,8 +197,13 @@ def apply_chaining(self):
             live_in, live_out = self.compute_liveness()
             _continue = False
 
+            inlined_into = None
             # XXX O(N^2) algorithm
-            for nodeA, nodeB in sliding_window(self.sorted_vertices):
+            for nodeB, nodeA in sliding_window(reversed(self.sorted_vertices)):
+                if inlined_into is not None:
+                    nodeB = inlined_into
+                    inlined_into = None
+
                 if self.graph.in_degree(nodeB) == 2:
                     continue  # start of do/while loop
 
@@ -215,7 +220,7 @@ def apply_chaining(self):
 
                 self.__inline_node(nodeB, nodeA)
                 _continue = True
-                break
+                inlined_into = nodeB
 
     def dead_code_elimination(self):
         """Dead code elimination.