[pypy-commit] pypy jit-short_from_state: merged getfield_gc support in short preamble manually

[hakanardo]

Author: Hakan Ardo <hakan at debian.org>
Branch: jit-short_from_state
Changeset: r45211:bbd855e7d8bf
Date: 2011-07-01 08:11 +0200
http://bitbucket.org/pypy/pypy/changeset/bbd855e7d8bf/

Log:	merged getfield_gc support in short preamble manually

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
@@ -4,6 +4,7 @@
 from pypy.rlib.objectmodel import we_are_translated
 from pypy.jit.metainterp.jitexc import JitException
 from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
+from pypy.jit.metainterp.history import ConstInt, Const
 
 
 class CachedField(object):
@@ -23,6 +24,7 @@
         #      'cached_fields'.
         #
         self._cached_fields = {}
+        self._cached_fields_getfield_op = {}        
         self._lazy_setfield = None
         self._lazy_setfield_registered = False
 
@@ -69,9 +71,10 @@
         else:
             return self._cached_fields.get(structvalue, None)
 
-    def remember_field_value(self, structvalue, fieldvalue):
+    def remember_field_value(self, structvalue, fieldvalue, getfield_op=None):
         assert self._lazy_setfield is None
         self._cached_fields[structvalue] = fieldvalue
+        self._cached_fields_getfield_op[structvalue] = getfield_op        
 
     def force_lazy_setfield(self, optheap):
         op = self._lazy_setfield
@@ -80,7 +83,7 @@
             # Now we clear _cached_fields, because actually doing the
             # setfield might impact any of the stored result (because of
             # possible aliasing).
-            self._cached_fields.clear()
+            self.clear()
             self._lazy_setfield = None
             optheap.next_optimization.propagate_forward(op)
             # Once it is done, we can put at least one piece of information
@@ -90,15 +93,38 @@
             fieldvalue  = optheap.getvalue(op.getarglist()[-1])
             self.remember_field_value(structvalue, fieldvalue)
 
-    def get_reconstructed(self, optimizer, valuemap):
+    def clear(self):
+        self._cached_fields.clear()
+        self._cached_fields_getfield_op.clear()
+
+    def turned_constant(self, newvalue, value):
+        if newvalue not in self._cached_fields:
+            self._cached_fields[newvalue] = self._cached_fields[value]
+            op = self._cached_fields_getfield_op[value].clone()
+            constbox = value.box
+            assert isinstance(constbox, Const)
+            op.setarg(0, constbox)
+            self._cached_fields_getfield_op[newvalue] = op
+
+    def get_cloned(self, optimizer, valuemap, short_boxes):
         assert self._lazy_setfield is None
         cf = CachedField()
         for structvalue, fieldvalue in self._cached_fields.iteritems():
-            structvalue2 = structvalue.get_reconstructed(optimizer, valuemap)
-            fieldvalue2  = fieldvalue .get_reconstructed(optimizer, valuemap)
-            cf._cached_fields[structvalue2] = fieldvalue2
+            op = self._cached_fields_getfield_op.get(structvalue, None)
+            if op and op.result in short_boxes and short_boxes[op.result] is op:
+                structvalue2 = structvalue.get_cloned(optimizer, valuemap)
+                fieldvalue2  = fieldvalue .get_cloned(optimizer, valuemap)
+                cf._cached_fields[structvalue2] = fieldvalue2
         return cf
 
+    def produce_potential_short_preamble_ops(self, optimizer,
+                                             potential_ops, descr):
+        if self._lazy_setfield is not None:
+            return
+        for structvalue, op in self._cached_fields_getfield_op.iteritems():
+            if op and structvalue in self._cached_fields:
+                potential_ops[op.result] = op
+
 
 class BogusPureField(JitException):
     pass
@@ -126,10 +152,10 @@
     def reconstruct_for_next_iteration(self,  short_boxes, surviving_boxes,
                                        optimizer, valuemap):
         new = OptHeap()
-        return new
 
         for descr, d in self.cached_fields.items():
-            new.cached_fields[descr] = d.get_reconstructed(optimizer, valuemap)
+            new.cached_fields[descr] = d.get_cloned(optimizer, valuemap, short_boxes)
+        return new
 
         for descr, submap in self.cached_arrayitems.items():
             newdict = {}
@@ -139,6 +165,12 @@
 
         return new
 
+    def produce_potential_short_preamble_ops(self, potential_ops):
+        for descr, d in self.cached_fields.items():
+            d.produce_potential_short_preamble_ops(self.optimizer,
+                                                   potential_ops, descr)
+        
+
     def clean_caches(self):
         del self._lazy_setfields_and_arrayitems[:]
         self.cached_fields.clear()
@@ -208,7 +240,7 @@
                     self.force_lazy_setfield(fielddescr)
                     try:
                         cf = self.cached_fields[fielddescr]
-                        cf._cached_fields.clear()
+                        cf.clear()
                     except KeyError:
                         pass
                 for arraydescr in effectinfo.write_descrs_arrays:
@@ -235,11 +267,11 @@
         if value is not newvalue:
             for cf in self.cached_fields.itervalues():
                 if value in cf._cached_fields:
-                    cf._cached_fields[newvalue] = cf._cached_fields[value]
+                    cf.turned_constant(newvalue, value)
             for submap in self.cached_arrayitems.itervalues():
                 for cf in submap.itervalues():
                     if value in cf._cached_fields:
-                        cf._cached_fields[newvalue] = cf._cached_fields[value]
+                        cf.turned_constant(newvalue, value)
 
     def force_lazy_setfield(self, descr):
         try:
@@ -341,7 +373,7 @@
         self.emit_operation(op)
         # then remember the result of reading the field
         fieldvalue = self.getvalue(op.result)
-        cf.remember_field_value(structvalue, fieldvalue)
+        cf.remember_field_value(structvalue, fieldvalue, op)
 
     def optimize_SETFIELD_GC(self, op):
         if self.has_pure_result(rop.GETFIELD_GC_PURE, [op.getarg(0)],