[pypy-svn] pypy jit-short_from_state: Extracting boxes suitable for short preamble. Only considering pure operation so far

[hakanardo]

Author: Hakan Ardo <hakan at debian.org>
Branch: jit-short_from_state
Changeset: r43008:03e22e9ee2f1
Date: 2011-03-30 07:58 +0200
http://bitbucket.org/pypy/pypy/changeset/03e22e9ee2f1/

Log:	Extracting boxes suitable for short preamble. Only considering pure
	operation so far

diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -162,6 +162,11 @@
             modifier = VirtualStateAdder(self.optimizer)
             virtual_state = modifier.get_virtual_state(jump_args)
 
+            values = [self.getvalue(arg) for arg in jump_args]
+            inputargs = virtual_state.make_inputargs(values)
+            short_boxes = preamble_optimizer.produce_short_preamble_ops(inputargs)
+            print short_boxes
+
             try:
                 inputargs = self.inline(self.cloned_operations,
                                         loop.inputargs, jump_args,

diff --git a/pypy/jit/metainterp/optimizeopt/heap.py b/pypy/jit/metainterp/optimizeopt/heap.py
--- a/pypy/jit/metainterp/optimizeopt/heap.py
+++ b/pypy/jit/metainterp/optimizeopt/heap.py
@@ -119,6 +119,7 @@
         self._lazy_setfields = []
         # cached array items:  {descr: CachedArrayItems}
         self.cached_arrayitems = {}
+        self.original_producer = {}
 
     def reconstruct_for_next_iteration(self, surviving_boxes,
                                        optimizer, valuemap):

diff --git a/pypy/jit/metainterp/optimizeopt/optimizer.py b/pypy/jit/metainterp/optimizeopt/optimizer.py
--- a/pypy/jit/metainterp/optimizeopt/optimizer.py
+++ b/pypy/jit/metainterp/optimizeopt/optimizer.py
@@ -254,6 +254,11 @@
         #return self.__class__()
         raise NotImplementedError
 
+    def produce_potential_short_preamble_ops(self, potential_ops):
+        pass
+
+class BoxNotProducable(Exception):
+    pass
 
 class Optimizer(Optimization):
 
@@ -266,6 +271,7 @@
         self.resumedata_memo = resume.ResumeDataLoopMemo(metainterp_sd)
         self.bool_boxes = {}
         self.pure_operations = args_dict()
+        self.emitted_pure_operations = {}
         self.producer = {}
         self.pendingfields = []
         self.posponedop = None
@@ -302,6 +308,7 @@
         assert valuemap is None
         if surviving_boxes is None:
             surviving_boxes = []
+
         valuemap = {}
         new = Optimizer(self.metainterp_sd, self.loop)
         optimizations = [o.reconstruct_for_next_iteration(surviving_boxes,
@@ -325,9 +332,45 @@
                                      force_if_needed=force)
             if value is not None:
                 new.values[box] = value
-            
+                
         return new
 
+    def produce_potential_short_preamble_ops(self, potential_ops):
+        for op in self.emitted_pure_operations:
+            potential_ops[op.result] = op
+        for opt in self.optimizations:
+            opt.produce_potential_short_preamble_ops(potential_ops)
+
+    def produce_short_preamble_ops(self, inputargs):
+        potential_ops = {}
+        self.produce_potential_short_preamble_ops(potential_ops)
+        
+        short_boxes = {}
+        for box in inputargs:
+            short_boxes[box] = None
+        for box in potential_ops.keys():
+            try:
+                self.produce_short_preamble_box(box, short_boxes,
+                                                potential_ops)
+            except BoxNotProducable:
+                pass
+        return short_boxes
+
+    def produce_short_preamble_box(self, box, short_boxes, potential_ops):
+        if box in short_boxes:
+            return 
+        if self.getvalue(box).is_constant():
+            return 
+        if box in potential_ops:
+            op = potential_ops[box]
+            for arg in op.getarglist():
+                arg = self.getvalue(arg).get_key_box()
+                self.produce_short_preamble_box(arg, short_boxes,
+                                                potential_ops)
+            short_boxes[box] = op
+        else:
+            raise BoxNotProducable
+
     def turned_constant(self, value):
         for o in self.optimizations:
             o.turned_constant(value)
@@ -548,6 +591,7 @@
                 return
             else:
                 self.pure_operations[args] = op
+                self.emitted_pure_operations[op] = True
 
         # otherwise, the operation remains
         self.emit_operation(op)