[pypy-commit] pypy optresult-unroll: port test_optimizeopt to the new style

[fijal]

Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: optresult-unroll
Changeset: r78458:775e4245077a
Date: 2015-07-06 15:59 +0200
http://bitbucket.org/pypy/pypy/changeset/775e4245077a/

Log:	port test_optimizeopt to the new style

diff --git a/rpython/jit/metainterp/compile.py b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -52,7 +52,6 @@
             opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
             return opt.optimize_preamble(self.start_label, self.end_label,
                                          self.operations)
-            xxx
         else:
             xxx
 
@@ -68,11 +67,32 @@
     def optimize(self, metainterp_sd, jitdriver_sd, optimizations, unroll):
         from rpython.jit.metainterp.optimizeopt.optimizer import Optimizer
 
+        assert not unroll
         opt = Optimizer(metainterp_sd, jitdriver_sd, optimizations)
         return opt.propagate_all_forward(self.start_label.getarglist(),
                                          self.operations,
                                          self.call_pure_results)
 
+class UnrolledLoopData(CompileData):
+    """ This represents label() ops jump with extra info that's from the
+    run of LoopCompileData
+    """
+    def __init__(self, start_label, end_jump, operations, state,
+                 call_pure_results=None):
+        self.start_label = start_label
+        self.end_jump = end_jump
+        self.operations = operations
+        self.state = state
+        self.call_pure_results = call_pure_results
+
+    def optimize(self, metainterp_sd, jitdriver_sd, optimizations, unroll):
+        from rpython.jit.metainterp.optimizeopt.unroll import UnrollOptimizer
+
+        assert unroll # we should not be here if it's disabled
+        opt = UnrollOptimizer(metainterp_sd, jitdriver_sd, optimizations)
+        return opt.optimize_peeled_loop(self.start_label, self.end_jump,
+                                        self.operations, self.state)
+
 def show_procedures(metainterp_sd, procedure=None, error=None):
     # debugging
     if option and (option.view or option.viewloops):
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -73,9 +73,6 @@
     enable_opts = "intbounds:rewrite:virtualize:string:earlyforce:pure:heap"
 
     def optimize_loop(self, ops, optops, call_pure_results=None):
-        from rpython.jit.metainterp.optimizeopt.util import args_dict
-
-                
         loop = self.parse(ops, postprocess=self.postprocess)
         token = JitCellToken()
         label_op = ResOperation(rop.LABEL, loop.inputargs,
@@ -84,11 +81,7 @@
             loop.operations[-1].setdescr(token)
         exp = parse(optops, namespace=self.namespace.copy())
         expected = convert_old_style_to_targets(exp, jump=True)
-        if call_pure_results is not None:
-            d = call_pure_results
-            call_pure_results = args_dict()
-            for k, v in d.items():
-                call_pure_results[list(k)] = v
+        call_pure_results = self._convert_call_pure_results(call_pure_results)
         compile_data = compile.SimpleCompileData(label_op, loop.operations,
                                                  call_pure_results)
         _, ops = self._do_optimize_loop(compile_data)
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -418,8 +418,36 @@
         compile_data.forget_optimization_info()
         return state
 
+    def _convert_call_pure_results(self, d):
+        from rpython.jit.metainterp.optimizeopt.util import args_dict
+
+        if d is None:
+            return
+        call_pure_results = args_dict()
+        for k, v in d.items():
+            call_pure_results[list(k)] = v
+        return call_pure_results
+
     def unroll_and_optimize(self, loop, call_pure_results=None):
-        xxx
+        jump_op = loop.operations[-1]
+        assert jump_op.getopnum() == rop.JUMP
+        ops = loop.operations[:-1]
+        start_label = ResOperation(rop.LABEL, loop.inputargs)
+        end_label = jump_op.copy_and_change(opnum=rop.LABEL)
+        preamble_data = compile.LoopCompileData(start_label, end_label, ops)
+        start_state, preamble_ops = self._do_optimize_loop(preamble_data,
+                                                  call_pure_results)
+        preamble_data.forget_optimization_info()
+        loop_data = compile.UnrolledLoopData(end_label, jump_op,
+                                             ops + [jump_op], start_state)
+        _, ops = self._do_optimize_loop(loop_data, call_pure_results)
+        preamble = TreeLoop('preamble')
+        preamble.inputargs = start_label.getarglist()
+        preamble.operations = [start_label] + preamble_ops
+        loop.operations = [end_label] + ops
+        return preamble
+
+    def foo(self):
         metainterp_sd = FakeMetaInterpStaticData(self.cpu)
         self.add_guard_future_condition(loop)
         operations =  loop.operations
diff --git a/rpython/jit/metainterp/optimizeopt/unroll.py b/rpython/jit/metainterp/optimizeopt/unroll.py
--- a/rpython/jit/metainterp/optimizeopt/unroll.py
+++ b/rpython/jit/metainterp/optimizeopt/unroll.py
@@ -62,6 +62,14 @@
         self.optimizer.propagate_all_forward(start_label.getarglist(), ops)
         exported_state = self.export_state(start_label, end_label)
         return exported_state, self.optimizer._newoperations
+
+    def optimize_peeled_loop(self, start_label, end_jump, ops, state):
+        self._check_no_forwarding([[start_label, end_jump], ops])
+        self.import_state(start_label, state)
+        self.optimizer.propagate_all_forward(start_label.getarglist(), ops)
+        return None, self.optimizer._newoperations
+
+    def random_garbage(self):
         # WTF is the rest of this function
         if not jumpop:
             return
@@ -211,12 +219,9 @@
         return ExportedState([], [])
 
     def import_state(self, targetop, exported_state):
-        if not targetop: # Trace did not start with a label
-            self.inputargs = self.optimizer.loop.inputargs
-            self.short = None
-            self.initial_virtual_state = None
-            return
-
+        for source, target in exported_state.inputarg_mapping:
+            xxx
+        return
         self.inputargs = targetop.getarglist()
         target_token = targetop.getdescr()
         assert isinstance(target_token, TargetToken)