[pypy-svn] r65977 - in pypy/branch/pyjitpl5/pypy: jit/metainterp jit/metainterp/test rlib

fijal at codespeak.net fijal at codespeak.net
Fri Jun 26 00:05:40 CEST 2009


Author: fijal
Date: Fri Jun 26 00:05:39 2009
New Revision: 65977

Modified:
   pypy/branch/pyjitpl5/pypy/jit/metainterp/pyjitpl.py
   pypy/branch/pyjitpl5/pypy/jit/metainterp/test/test_recursive.py
   pypy/branch/pyjitpl5/pypy/jit/metainterp/warmspot.py
   pypy/branch/pyjitpl5/pypy/rlib/jit.py
Log:
Enough of a hack for an interpreter to provide a simple check whether
function is inlineable or not. To be here as long as we don't find
out something a bit more fancy


Modified: pypy/branch/pyjitpl5/pypy/jit/metainterp/pyjitpl.py
==============================================================================
--- pypy/branch/pyjitpl5/pypy/jit/metainterp/pyjitpl.py	(original)
+++ pypy/branch/pyjitpl5/pypy/jit/metainterp/pyjitpl.py	Fri Jun 26 00:05:39 2009
@@ -582,8 +582,11 @@
     @arguments("descr", "varargs")
     def opimpl_recursive_call(self, calldescr, varargs):
         if self.metainterp.staticdata.options.inline:
+            num_green_args = self.metainterp.staticdata.num_green_args
             portal_code = self.metainterp.staticdata.portal_code
-            return self.perform_call(portal_code, varargs[1:])
+            greenkey = varargs[1:num_green_args + 1]
+            if self.metainterp.staticdata.warmrunnerdesc.can_inline_callable(greenkey):
+                return self.perform_call(portal_code, varargs[1:])
         return self.execute_with_exc(rop.CALL, varargs, descr=calldescr)
 
     @arguments("descr", "varargs")

Modified: pypy/branch/pyjitpl5/pypy/jit/metainterp/test/test_recursive.py
==============================================================================
--- pypy/branch/pyjitpl5/pypy/jit/metainterp/test/test_recursive.py	(original)
+++ pypy/branch/pyjitpl5/pypy/jit/metainterp/test/test_recursive.py	Fri Jun 26 00:05:39 2009
@@ -3,7 +3,7 @@
 from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
 from pypy.jit.metainterp.simple_optimize import Optimizer
 from pypy.jit.metainterp.policy import StopAtXPolicy
-
+from pypy.rpython.annlowlevel import hlstr
 
 class RecursiveTests:
 
@@ -100,10 +100,14 @@
         JUMP_BACK = "1"
         CALL = "2"
 
-        jitdriver = JitDriver(greens = ['code', 'i'], reds = ['n'])
+        def can_inline(code, i):
+            code = hlstr(code)
+            return not JUMP_BACK in code
+
+        jitdriver = JitDriver(greens = ['code', 'i'], reds = ['n'],
+                              can_inline = can_inline)
  
-        def interpret(codenum, n):
-            i = 0
+        def interpret(codenum, n, i):
             code = codes[codenum]
             while i < len(code):
                 jitdriver.jit_merge_point(n=n, i=i, code=code)
@@ -112,7 +116,7 @@
                     n += 1
                     i += 1
                 elif op == CALL:
-                    n = interpret(1, n)
+                    n = interpret(1, n, 1)
                     i += 1
                 elif op == JUMP_BACK:
                     if n > 20:
@@ -126,18 +130,28 @@
         return interpret
 
     def test_inline(self):
-
         code = "021"
-        subcode = "0"
+        subcode = "00"
 
         codes = ["021", "0"]
         f = self.get_interpreter(codes)
 
-        assert self.meta_interp(f, [0, 0], optimizer=Optimizer) == 42
+        assert self.meta_interp(f, [0, 0, 0], optimizer=Optimizer) == 42
         self.check_loops(int_add = 1, call = 1)
-        assert self.meta_interp(f, [0, 0], optimizer=Optimizer,
+        assert self.meta_interp(f, [0, 0, 0], optimizer=Optimizer,
+                                inline=True) == 42
+        self.check_loops(int_add = 2, call = 0, guard_no_exception = 0)
+
+    def test_inline_jitdriver_check(self):
+        code = "021"
+        subcode = "100"
+        codes = [code, subcode]
+
+        f = self.get_interpreter(codes)
+
+        assert self.meta_interp(f, [0, 0, 0], optimizer=Optimizer,
                                 inline=True) == 42
-        self.check_loops(int_add = 2, call = 0, guard_no_exception = 0)        
+        self.check_loops(call = 1)
 
 class TestLLtype(RecursiveTests, LLJitMixin):
     pass

Modified: pypy/branch/pyjitpl5/pypy/jit/metainterp/warmspot.py
==============================================================================
--- pypy/branch/pyjitpl5/pypy/jit/metainterp/warmspot.py	(original)
+++ pypy/branch/pyjitpl5/pypy/jit/metainterp/warmspot.py	Fri Jun 26 00:05:39 2009
@@ -32,6 +32,7 @@
 
 def apply_jit(translator, backend_name="auto", **kwds):
     from pypy.jit.metainterp import optimize4 as Optimizer
+    #from pypy.jit.metainterp.simple_optimize import Optimizer
     if 'CPUClass' not in kwds:
         from pypy.jit.backend.detect_cpu import getcpuclass
         kwds['CPUClass'] = getcpuclass(backend_name)
@@ -48,7 +49,8 @@
     warmrunnerdesc.finish()
     translator.warmrunnerdesc = warmrunnerdesc    # for later debugging
 
-def ll_meta_interp(function, args, backendopt=False, type_system='lltype', **kwds):
+def ll_meta_interp(function, args, backendopt=False, type_system='lltype',
+                   **kwds):
     interp, graph = get_interpreter(function, args,
                                     backendopt=backendopt,
                                     type_system=type_system,
@@ -141,6 +143,7 @@
         self.add_profiler_finish()
         self.metainterp_sd.finish_setup()
         # hook back for set_param
+        self.make_can_inline_graph()
         self.jitdriver.state = self.state
 
     def finish(self):
@@ -238,6 +241,19 @@
 
         self.maybe_enter_jit_fn = maybe_enter_jit
 
+    def make_can_inline_graph(self):
+        if self.jitdriver.can_inline is None:
+            self.jitdriver.can_inline_graph = None
+            return
+        annhelper = MixLevelHelperAnnotator(self.translator.rtyper)
+        func = self.jitdriver.can_inline
+        FUNC, PTR = self.ts.get_FuncType(self.green_args_spec, lltype.Bool)
+        args_s = [annmodel.lltype_to_annotation(ARG) for ARG in FUNC.ARGS]
+        s_result = annmodel.lltype_to_annotation(FUNC.RESULT)
+        graph = annhelper.getgraph(func, args_s, s_result)
+        self.can_inline_ptr = annhelper.graph2delayed(graph, FUNC)
+        annhelper.finish()
+
     def make_args_specification(self):
         graph, block, index = self.jit_merge_point_pos
         op = block.operations[index]
@@ -444,6 +460,26 @@
                         value = cast_base_ptr_to_instance(Exception, value)
                         raise Exception, value
 
+        if self.jitdriver.can_inline is None:
+            def can_inline_callable(greenkey):
+                return True
+        else:
+            def unwrap_greenkey(greenkey):
+                greenargs = ()
+                i = 0
+                for TYPE in self.green_args_spec:
+                    value = unwrap(TYPE, greenkey[i])
+                    greenargs += (value,)
+                    i = i + 1
+                return greenargs
+            unwrap_greenkey._always_inline_ = True
+            
+            def can_inline_callable(greenkey):
+                args = unwrap_greenkey(greenkey)
+                return support.maybe_on_top_of_llinterp(rtyper, self.can_inline_ptr)(*args)
+
+        self.can_inline_callable = can_inline_callable
+
         ll_portal_runner._recursive_portal_call_ = True
 
         portal_runner_ptr = self.helper_func(self.PTR_PORTAL_FUNCTYPE,

Modified: pypy/branch/pyjitpl5/pypy/rlib/jit.py
==============================================================================
--- pypy/branch/pyjitpl5/pypy/rlib/jit.py	(original)
+++ pypy/branch/pyjitpl5/pypy/rlib/jit.py	Fri Jun 26 00:05:39 2009
@@ -94,7 +94,8 @@
     virtualizables = []
     optimizer_name = '<undefined>'
     
-    def __init__(self, greens=None, reds=None, virtualizables=None):
+    def __init__(self, greens=None, reds=None, virtualizables=None,
+                 can_inline=None):
         if greens is not None:
             self.greens = greens
         if reds is not None:
@@ -107,6 +108,7 @@
             assert v in self.reds
         self._alllivevars = dict.fromkeys(self.greens + self.reds)
         self._make_extregistryentries()
+        self.can_inline = can_inline
 
     def _freeze_(self):
         return True



More information about the Pypy-commit mailing list