[pypy-svn] pypy jit-short-preamble: emit proper guards when inlining short preamble

hakanardo commits-noreply at bitbucket.org
Fri Jan 21 12:16:22 CET 2011


Author: Hakan Ardo <hakan at debian.org>
Branch: jit-short-preamble
Changeset: r41114:d8cf88e52239
Date: 2011-01-20 17:51 +0100
http://bitbucket.org/pypy/pypy/changeset/d8cf88e52239/

Log:	emit proper guards when inlining short preamble

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
@@ -178,8 +178,9 @@
                     op = short[i]
                     if op.is_guard():
                         op = op.clone()
-                        op.setfailargs(loop.preamble.inputargs)
-                        op.setjumptarget(loop.preamble.token)
+                        #op.setfailargs(loop.preamble.inputargs)
+                        #op.setjumptarget(loop.preamble.token)
+                        op.setdescr(loop.preamble.token.start_resumedescr)
                         short[i] = op
 
                 short_loop = TreeLoop('short preamble')
@@ -566,26 +567,6 @@
             newop = inliner.inline_op(op)
             
             if not dryrun:
-                # FIXME: Emit a proper guard instead to move these
-                # forceings into the the small bridge back to the preamble
-                if newop.is_guard():
-                    failargs = newop.getfailargs()
-                    for i in range(len(failargs)):
-                        box = failargs[i]
-                        if box in self.optimizer.values:
-                            value = self.optimizer.values[box]
-                            if value.is_constant():
-                                newbox = box.clonebox()
-                                op = ResOperation(rop.SAME_AS,
-                                                  [value.force_box()], newbox)
-                                self.optimizer.newoperations.append(op)
-                                box = newbox
-                            else:
-                                box = value.force_box()
-                        failargs[i] = box
-                    newop.setfailargs(failargs)
-                                
-                
                 self.emit_operation(newop)
             else:
                 if not self.is_emittable(newop):

diff --git a/pypy/jit/metainterp/compile.py b/pypy/jit/metainterp/compile.py
--- a/pypy/jit/metainterp/compile.py
+++ b/pypy/jit/metainterp/compile.py
@@ -80,11 +80,11 @@
 
 # ____________________________________________________________
 
-def compile_new_loop(metainterp, old_loop_tokens, greenkey, start,
-                     full_preamble_needed=True):
+def compile_new_loop(metainterp, old_loop_tokens, greenkey, start, start_resumedescr):
     """Try to compile a new loop by closing the current history back
     to the first operation.
     """
+    full_preamble_needed=True
     history = metainterp.history
     loop = create_empty_loop(metainterp)
     loop.inputargs = history.inputargs
@@ -102,6 +102,7 @@
     loop.preamble = create_empty_loop(metainterp, 'Preamble ')
     loop.preamble.inputargs = loop.inputargs
     loop.preamble.token = make_loop_token(len(loop.inputargs), jitdriver_sd)
+    loop.preamble.token.start_resumedescr = start_resumedescr
 
     try:
         old_loop_token = jitdriver_sd.warmstate.optimize_loop(

diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -832,6 +832,9 @@
     @arguments("orgpc", "int", "boxes3", "jitcode_position", "boxes3")
     def opimpl_jit_merge_point(self, orgpc, jdindex, greenboxes,
                                jcposition, redboxes):
+        resumedescr = compile.ResumeGuardDescr()
+        self.capture_resumedata(resumedescr)
+
         any_operation = len(self.metainterp.history.operations) > 0
         jitdriver_sd = self.metainterp.staticdata.jitdrivers_sd[jdindex]
         self.verify_green_args(jitdriver_sd, greenboxes)
@@ -857,7 +860,7 @@
             # much less expensive to blackhole out of.
             saved_pc = self.pc
             self.pc = orgpc
-            self.metainterp.reached_loop_header(greenboxes, redboxes)
+            self.metainterp.reached_loop_header(greenboxes, redboxes, resumedescr)
             self.pc = saved_pc
             # no exception, which means that the jit_merge_point did not
             # close the loop.  We have to put the possibly-modified list
@@ -1075,6 +1078,14 @@
             resumedescr = compile.ResumeGuardDescr()
         guard_op = metainterp.history.record(opnum, moreargs, None,
                                              descr=resumedescr)
+        self.capture_resumedata(resumedescr, resumepc)
+        self.metainterp.staticdata.profiler.count_ops(opnum, GUARDS)
+        # count
+        metainterp.attach_debug_info(guard_op)
+        return guard_op
+
+    def capture_resumedata(self, resumedescr, resumepc=-1):
+        metainterp = self.metainterp
         virtualizable_boxes = None
         if (metainterp.jitdriver_sd.virtualizable_info is not None or
             metainterp.jitdriver_sd.greenfield_info is not None):
@@ -1085,10 +1096,6 @@
         resume.capture_resumedata(metainterp.framestack, virtualizable_boxes,
                                   metainterp.virtualref_boxes, resumedescr)
         self.pc = saved_pc
-        self.metainterp.staticdata.profiler.count_ops(opnum, GUARDS)
-        # count
-        metainterp.attach_debug_info(guard_op)
-        return guard_op
 
     def implement_guard_value(self, orgpc, box):
         """Promote the given Box into a Const.  Note: be careful, it's a
@@ -1734,7 +1741,7 @@
             else:
                 duplicates[box] = None
 
-    def reached_loop_header(self, greenboxes, redboxes):
+    def reached_loop_header(self, greenboxes, redboxes, resumedescr):
         duplicates = {}
         self.remove_consts_and_duplicates(redboxes, len(redboxes),
                                           duplicates)
@@ -1791,7 +1798,7 @@
                                                  live_arg_boxes, start,
                                                  bridge_arg_boxes)
                 else:
-                    self.compile(original_boxes, live_arg_boxes, start)
+                    self.compile(original_boxes, live_arg_boxes, start, resumedescr)
                 # creation of the loop was cancelled!
                 #self.staticdata.log('cancelled, tracing more...')
                 self.staticdata.log('cancelled, stopping tracing')
@@ -1854,14 +1861,14 @@
         cell = self.jitdriver_sd.warmstate.jit_cell_at_key(greenkey)
         cell.set_compiled_merge_points(looptokens)
 
-    def compile(self, original_boxes, live_arg_boxes, start):
+    def compile(self, original_boxes, live_arg_boxes, start, start_resumedescr):
         num_green_args = self.jitdriver_sd.num_green_args
         self.history.inputargs = original_boxes[num_green_args:]
         greenkey = original_boxes[:num_green_args]
         old_loop_tokens = self.get_compiled_merge_points(greenkey)
         self.history.record(rop.JUMP, live_arg_boxes[num_green_args:], None)
         loop_token = compile.compile_new_loop(self, old_loop_tokens,
-                                              greenkey, start)
+                                              greenkey, start, start_resumedescr)
         if loop_token is not None: # raise if it *worked* correctly
             self.set_compiled_merge_points(greenkey, old_loop_tokens)
             raise GenerateMergePoint(live_arg_boxes, loop_token)


More information about the Pypy-commit mailing list