[pypy-svn] pypy enable-opts: Implement "enable_opts" as a replacement for various ad-hoc enabling/disabling
fijal
commits-noreply at bitbucket.org
Thu Mar 10 22:55:20 CET 2011
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: enable-opts
Changeset: r42498:67c539df0eb6
Date: 2011-03-10 16:54 -0500
http://bitbucket.org/pypy/pypy/changeset/67c539df0eb6/
Log: Implement "enable_opts" as a replacement for various ad-hoc
enabling/disabling of optimizations. Export this at applevel as
--jit enable_opts=...:...:...
diff --git a/pypy/config/translationoption.py b/pypy/config/translationoption.py
--- a/pypy/config/translationoption.py
+++ b/pypy/config/translationoption.py
@@ -117,7 +117,6 @@
ChoiceOption("jit_profiler", "integrate profiler support into the JIT",
["off", "oprofile"],
default="off"),
- BoolOption("jit_ffi", "optimize libffi calls", default=False),
# misc
BoolOption("verbose", "Print extra information", default=False),
diff --git a/pypy/jit/metainterp/test/test_virtualizable.py b/pypy/jit/metainterp/test/test_virtualizable.py
--- a/pypy/jit/metainterp/test/test_virtualizable.py
+++ b/pypy/jit/metainterp/test/test_virtualizable.py
@@ -5,7 +5,6 @@
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.codewriter import heaptracker
from pypy.rlib.jit import JitDriver, hint, dont_look_inside
-from pypy.rlib.jit import OPTIMIZER_SIMPLE, OPTIMIZER_FULL
from pypy.rlib.rarithmetic import intmask
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
from pypy.rpython.rclass import FieldListAccessor
@@ -374,7 +373,7 @@
promote_virtualizable(xy2, 'inst_l2')
return xy2.inst_l2[0]
expected = f(20)
- res = self.meta_interp(f, [20], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [20], enable_opts='')
assert res == expected
self.check_loops(getfield_gc=3, setfield_gc=0,
arraylen_gc=1, getarrayitem_gc=1, setarrayitem_gc=1)
@@ -1369,8 +1368,7 @@
frame = Frame(n)
return f("c-l", frame)
print main(100)
- res = self.meta_interp(main, [100], inline=True,
- optimizer=OPTIMIZER_FULL)
+ res = self.meta_interp(main, [100], inline=True, enable_opts='')
class TestOOtype(#ExplicitVirtualizableTests,
ImplicitVirtualizableTests,
diff --git a/pypy/jit/metainterp/test/test_optimizeopt.py b/pypy/jit/metainterp/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/test/test_optimizeopt.py
@@ -5,7 +5,7 @@
BaseTest)
import pypy.jit.metainterp.optimizeopt.optimizer as optimizeopt
import pypy.jit.metainterp.optimizeopt.virtualize as virtualize
-from pypy.jit.metainterp.optimizeopt import optimize_loop_1
+from pypy.jit.metainterp.optimizeopt import optimize_loop_1, ALL_OPTS_DICT
from pypy.jit.metainterp.optimizeutil import InvalidLoop
from pypy.jit.metainterp.history import AbstractDescr, ConstInt, BoxInt
from pypy.jit.metainterp.history import TreeLoop, LoopToken
@@ -188,7 +188,7 @@
def clone_if_mutable(self):
return self
loop.preamble.start_resumedescr = FakeDescr()
- optimize_loop_1(metainterp_sd, loop)
+ optimize_loop_1(metainterp_sd, loop, ALL_OPTS_DICT)
#
print
diff --git a/pypy/jit/metainterp/optimize.py b/pypy/jit/metainterp/optimize.py
--- a/pypy/jit/metainterp/optimize.py
+++ b/pypy/jit/metainterp/optimize.py
@@ -4,42 +4,44 @@
from pypy.jit.metainterp.optimizeopt import optimize_loop_1, optimize_bridge_1
-def optimize_loop(metainterp_sd, old_loop_tokens, loop):
+def optimize_loop(metainterp_sd, old_loop_tokens, loop, enable_opts):
debug_start("jit-optimize")
try:
- return _optimize_loop(metainterp_sd, old_loop_tokens, loop)
+ return _optimize_loop(metainterp_sd, old_loop_tokens, loop,
+ enable_opts)
finally:
debug_stop("jit-optimize")
-def _optimize_loop(metainterp_sd, old_loop_tokens, loop):
+def _optimize_loop(metainterp_sd, old_loop_tokens, loop, enable_opts):
cpu = metainterp_sd.cpu
metainterp_sd.logger_noopt.log_loop(loop.inputargs, loop.operations)
# XXX do we really still need a list?
if old_loop_tokens:
return old_loop_tokens[0]
- optimize_loop_1(metainterp_sd, loop)
+ optimize_loop_1(metainterp_sd, loop, enable_opts)
return None
# ____________________________________________________________
-def optimize_bridge(metainterp_sd, old_loop_tokens, bridge,
+def optimize_bridge(metainterp_sd, old_loop_tokens, bridge, enable_opts,
inline_short_preamble=True, retraced=False):
debug_start("jit-optimize")
try:
return _optimize_bridge(metainterp_sd, old_loop_tokens, bridge,
+ enable_opts,
inline_short_preamble, retraced)
finally:
debug_stop("jit-optimize")
-def _optimize_bridge(metainterp_sd, old_loop_tokens, bridge,
+def _optimize_bridge(metainterp_sd, old_loop_tokens, bridge, enable_opts,
inline_short_preamble, retraced=False):
cpu = metainterp_sd.cpu
metainterp_sd.logger_noopt.log_loop(bridge.inputargs, bridge.operations)
if old_loop_tokens:
old_loop_token = old_loop_tokens[0]
bridge.operations[-1].setdescr(old_loop_token) # patch jump target
- optimize_bridge_1(metainterp_sd, bridge, inline_short_preamble,
- retraced)
+ optimize_bridge_1(metainterp_sd, bridge, enable_opts,
+ inline_short_preamble, retraced)
return old_loop_tokens[0]
#return bridge.operations[-1].getdescr()
return None
diff --git a/pypy/module/pypyjit/interp_jit.py b/pypy/module/pypyjit/interp_jit.py
--- a/pypy/module/pypyjit/interp_jit.py
+++ b/pypy/module/pypyjit/interp_jit.py
@@ -6,7 +6,7 @@
from pypy.tool.pairtype import extendabletype
from pypy.rlib.rarithmetic import r_uint, intmask
from pypy.rlib.jit import JitDriver, hint, we_are_jitted, dont_look_inside
-from pypy.rlib.jit import current_trace_length
+from pypy.rlib.jit import current_trace_length, unroll_parameters
import pypy.interpreter.pyopcode # for side-effects
from pypy.interpreter.error import OperationError, operationerrfmt
from pypy.interpreter.pycode import PyCode, CO_GENERATOR
@@ -136,12 +136,17 @@
raise OperationError(space.w_ValueError,
space.wrap("error in JIT parameters string"))
for key, w_value in kwds_w.items():
- intval = space.int_w(w_value)
- try:
- pypyjitdriver.set_param(key, intval)
- except ValueError:
- raise operationerrfmt(space.w_TypeError,
- "no JIT parameter '%s'", key)
+ if key == 'enable_opts':
+ pypyjitdriver.set_param('enable_opts', space.str_w(w_value))
+ else:
+ intval = space.int_w(w_value)
+ for name, _ in unroll_parameters:
+ if name == key and name != 'enable_opts':
+ pypyjitdriver.set_param(name, intval)
+ break
+ else:
+ raise operationerrfmt(space.w_TypeError,
+ "no JIT parameter '%s'", key)
@dont_look_inside
def residual_call(space, w_callable, __args__):
diff --git a/pypy/jit/metainterp/test/test_basic.py b/pypy/jit/metainterp/test/test_basic.py
--- a/pypy/jit/metainterp/test/test_basic.py
+++ b/pypy/jit/metainterp/test/test_basic.py
@@ -1,7 +1,7 @@
import py
import sys
from pypy.rlib.jit import JitDriver, we_are_jitted, hint, dont_look_inside
-from pypy.rlib.jit import OPTIMIZER_FULL, OPTIMIZER_SIMPLE, loop_invariant
+from pypy.rlib.jit import loop_invariant
from pypy.rlib.jit import jit_debug, assert_green, AssertGreenFailed
from pypy.rlib.jit import unroll_safe, current_trace_length
from pypy.jit.metainterp.warmspot import ll_meta_interp, get_stats
@@ -15,6 +15,7 @@
from pypy.jit.metainterp.typesystem import LLTypeHelper, OOTypeHelper
from pypy.rpython.lltypesystem import lltype, llmemory
from pypy.rpython.ootypesystem import ootype
+from pypy.jit.metainterp.optimizeopt import ALL_OPTS_DICT
def _get_jitcodes(testself, CPUClass, func, values, type_system,
supports_longlong=False, **kwds):
@@ -42,6 +43,7 @@
optimize_bridge = staticmethod(simple_optimize.optimize_bridge)
trace_limit = sys.maxint
+ enable_opts = ALL_OPTS_DICT
func._jit_unroll_safe_ = True
rtyper = support.annotate(func, values, type_system=type_system)
@@ -1176,7 +1178,7 @@
x += inst.foo
n -= 1
return x
- res = self.meta_interp(f, [20], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [20], enable_opts='')
assert res == f(20)
self.check_loops(call=0)
@@ -1379,8 +1381,7 @@
m = m >> 1
return x
- res = self.meta_interp(f, [50, 1],
- optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [50, 1], enable_opts='')
assert res == 42
def test_set_param(self):
@@ -2306,12 +2307,12 @@
res = self.meta_interp(f, [1, 100],
policy=StopAtXPolicy(getcls),
- optimizer=OPTIMIZER_SIMPLE)
+ enable_opts='')
assert not res
res = self.meta_interp(f, [0, 100],
policy=StopAtXPolicy(getcls),
- optimizer=OPTIMIZER_SIMPLE)
+ enable_opts='')
assert res
class BaseLLtypeTests(BasicTests):
@@ -2391,5 +2392,25 @@
self.meta_interp(main, [])
+ def test_enable_opts(self):
+ jitdriver = JitDriver(greens = [], reds = ['a'])
+
+ class A(object):
+ def __init__(self, i):
+ self.i = i
+
+ def f():
+ a = A(0)
+
+ while a.i < 10:
+ jitdriver.jit_merge_point(a=a)
+ jitdriver.can_enter_jit(a=a)
+ a = A(a.i + 1)
+
+ self.meta_interp(f, [])
+ self.check_loops(new_with_vtable=0)
+ self.meta_interp(f, [], enable_opts='')
+ self.check_loops(new_with_vtable=1)
+
class TestLLtype(BaseLLtypeTests, LLJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_send.py b/pypy/jit/metainterp/test/test_send.py
--- a/pypy/jit/metainterp/test/test_send.py
+++ b/pypy/jit/metainterp/test/test_send.py
@@ -2,10 +2,8 @@
from pypy.rlib.jit import JitDriver, hint, purefunction
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-from pypy.rlib.jit import OPTIMIZER_FULL, OPTIMIZER_SIMPLE
-class SendTests:
- optimizer=OPTIMIZER_FULL
+class SendTests(object):
def test_green_send(self):
myjitdriver = JitDriver(greens = ['i'], reds = ['counter'])
@@ -166,12 +164,8 @@
for j in range(69, 75):
res = self.meta_interp(f, [j], policy=policy)
assert res == 42
- if self.optimizer != OPTIMIZER_FULL:
- self.check_enter_count(3)
- self.check_loop_count(3)
- else:
- self.check_enter_count_at_most(5)
- self.check_loop_count_at_most(5)
+ self.check_enter_count_at_most(5)
+ self.check_loop_count_at_most(5)
def test_oosend_guard_failure(self):
myjitdriver = JitDriver(greens = [], reds = ['x', 'y', 'w'])
@@ -356,10 +350,7 @@
assert res == f(198)
# we get two TreeLoops: an initial one, and one entering from
# the interpreter
- if self.optimizer != OPTIMIZER_FULL:
- self.check_tree_loop_count(1)
- else:
- self.check_tree_loop_count(2)
+ self.check_tree_loop_count(2)
def test_indirect_call_unknown_object_3(self):
myjitdriver = JitDriver(greens = [], reds = ['x', 'y', 'z', 'state'])
@@ -396,10 +387,7 @@
assert res == f(198)
# we get two TreeLoops: an initial one, and one entering from
# the interpreter
- if self.optimizer != OPTIMIZER_FULL:
- self.check_tree_loop_count(1)
- else:
- self.check_tree_loop_count(2)
+ self.check_tree_loop_count(2)
def test_two_behaviors(self):
py.test.skip("XXX fix me!!!!!!! problem in optimize.py")
@@ -452,10 +440,7 @@
# we expect 1 loop, 1 entry bridge, and 1 bridge going from the
# loop back to the start of the entry bridge
self.check_loop_count(2) # 1 loop + 1 bridge
- if self.optimizer != OPTIMIZER_FULL:
- self.check_tree_loop_count(1) # 1 loop
- else:
- self.check_tree_loop_count(2) # 1 loop + 1 entry bridge (argh)
+ self.check_tree_loop_count(2) # 1 loop + 1 entry bridge (argh)
self.check_aborted_count(0)
def test_three_cases(self):
@@ -476,10 +461,7 @@
return node.x
res = self.meta_interp(f, [55])
assert res == f(55)
- if self.optimizer != OPTIMIZER_FULL:
- self.check_tree_loop_count(1)
- else:
- self.check_tree_loop_count(4)
+ self.check_tree_loop_count(4)
def test_three_classes(self):
class Base:
@@ -509,10 +491,7 @@
return n
res = self.meta_interp(f, [55], policy=StopAtXPolicy(extern))
assert res == f(55)
- if self.optimizer != OPTIMIZER_FULL:
- self.check_tree_loop_count(1)
- else:
- self.check_tree_loop_count(2)
+ self.check_tree_loop_count(2)
def test_bug1(self):
myjitdriver = JitDriver(greens = [], reds = ['n', 'node'])
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -2,7 +2,7 @@
import sys
from pypy.rpython.extregistry import ExtRegistryEntry
from pypy.rlib.objectmodel import CDefinedIntSymbolic
-from pypy.rlib.objectmodel import keepalive_until_here
+from pypy.rlib.objectmodel import keepalive_until_here, specialize
from pypy.rlib.unroll import unrolling_iterable
from pypy.rlib.nonconst import NonConstant
@@ -263,19 +263,15 @@
class JitHintError(Exception):
"""Inconsistency in the JIT hints."""
-OPTIMIZER_SIMPLE = 0
-OPTIMIZER_NO_UNROLL = 1
-OPTIMIZER_FULL = 2
-
PARAMETERS = {'threshold': 1000,
'trace_eagerness': 200,
'trace_limit': 10000,
- 'inlining': False,
- 'optimizer': OPTIMIZER_FULL,
+ 'inlining': 0,
'loop_longevity': 1000,
'retrace_limit': 5,
+ 'enable_opts': None, # patched later by optimizeopt/__init__.py
}
-unroll_parameters = unrolling_iterable(PARAMETERS.keys())
+unroll_parameters = unrolling_iterable(PARAMETERS.items())
# ____________________________________________________________
@@ -332,14 +328,14 @@
# (internal, must receive a constant 'name')
assert name in PARAMETERS
+ @specialize.arg(0, 1)
def set_param(self, name, value):
"""Set one of the tunable JIT parameter."""
- for name1 in unroll_parameters:
+ for name1, _ in unroll_parameters:
if name1 == name:
self._set_param(name1, value)
return
raise ValueError("no such parameter")
- set_param._annspecialcase_ = 'specialize:arg(0)'
def set_user_param(self, text):
"""Set the tunable JIT parameters from a user-supplied string
@@ -351,12 +347,17 @@
parts = s.split('=')
if len(parts) != 2:
raise ValueError
- try:
- value = int(parts[1])
- except ValueError:
- raise # re-raise the ValueError (annotator hint)
name = parts[0]
- self.set_param(name, value)
+ value = parts[1]
+ if name == 'enable_opts':
+ self.set_param('enable_opts', value)
+ else:
+ for name1, _ in unroll_parameters:
+ if name1 == name and name1 != 'enable_opts':
+ try:
+ self.set_param(name1, int(value))
+ except ValueError:
+ raise
set_user_param._annspecialcase_ = 'specialize:arg(0)'
def _make_extregistryentries(self):
@@ -537,7 +538,10 @@
def compute_result_annotation(self, s_name, s_value):
from pypy.annotation import model as annmodel
assert s_name.is_constant()
- assert annmodel.SomeInteger().contains(s_value)
+ if annmodel.SomeInteger().contains(s_value):
+ pass
+ else:
+ assert annmodel.SomeString().contains(s_value)
return annmodel.s_None
def specialize_call(self, hop):
@@ -545,7 +549,7 @@
hop.exception_cannot_occur()
driver = self.instance.im_self
name = hop.args_s[0].const
- v_value = hop.inputarg(lltype.Signed, arg=1)
+ v_value = hop.inputarg(hop.args_r[1], arg=1)
vlist = [hop.inputconst(lltype.Void, "set_param"),
hop.inputconst(lltype.Void, driver),
hop.inputconst(lltype.Void, name),
diff --git a/pypy/jit/metainterp/test/test_fficall.py b/pypy/jit/metainterp/test/test_fficall.py
--- a/pypy/jit/metainterp/test/test_fficall.py
+++ b/pypy/jit/metainterp/test/test_fficall.py
@@ -40,6 +40,6 @@
n += 1
return res
#
- res = self.meta_interp(f, [0], jit_ffi=True)
+ res = self.meta_interp(f, [0])
return res
diff --git a/pypy/jit/metainterp/test/test_del.py b/pypy/jit/metainterp/test/test_del.py
--- a/pypy/jit/metainterp/test/test_del.py
+++ b/pypy/jit/metainterp/test/test_del.py
@@ -1,5 +1,5 @@
import py
-from pypy.rlib.jit import JitDriver, OPTIMIZER_SIMPLE
+from pypy.rlib.jit import JitDriver
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
@@ -76,7 +76,7 @@
x += inst.foo
n -= 1
return 1
- res = self.meta_interp(f, [20], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [20], enable_opts='')
assert res == 1
self.check_loops(call=1) # for the case B(), but not for the case A()
diff --git a/pypy/jit/metainterp/test/test_ztranslation.py b/pypy/jit/metainterp/test/test_ztranslation.py
--- a/pypy/jit/metainterp/test/test_ztranslation.py
+++ b/pypy/jit/metainterp/test/test_ztranslation.py
@@ -1,7 +1,7 @@
import py
from pypy.jit.metainterp.warmspot import rpython_ll_meta_interp, ll_meta_interp
from pypy.jit.backend.llgraph import runner
-from pypy.rlib.jit import JitDriver, OPTIMIZER_FULL, unroll_parameters
+from pypy.rlib.jit import JitDriver, unroll_parameters
from pypy.rlib.jit import PARAMETERS, dont_look_inside
from pypy.jit.metainterp.jitprof import Profiler
from pypy.rpython.lltypesystem import lltype, llmemory
@@ -51,8 +51,7 @@
set_jitcell_at=set_jitcell_at,
get_printable_location=get_printable_location)
def f(i):
- for param in unroll_parameters:
- defl = PARAMETERS[param]
+ for param, defl in unroll_parameters:
jitdriver.set_param(param, defl)
jitdriver.set_param("threshold", 3)
jitdriver.set_param("trace_eagerness", 2)
diff --git a/pypy/jit/metainterp/optimizeopt/__init__.py b/pypy/jit/metainterp/optimizeopt/__init__.py
--- a/pypy/jit/metainterp/optimizeopt/__init__.py
+++ b/pypy/jit/metainterp/optimizeopt/__init__.py
@@ -5,37 +5,59 @@
from pypy.jit.metainterp.optimizeopt.heap import OptHeap
from pypy.jit.metainterp.optimizeopt.string import OptString
from pypy.jit.metainterp.optimizeopt.unroll import optimize_unroll, OptInlineShortPreamble
+from pypy.jit.metainterp.optimizeopt.fficall import OptFfiCall
+from pypy.jit.metainterp.optimizeopt.simplify import OptSimplify
+from pypy.rlib.jit import PARAMETERS
-def optimize_loop_1(metainterp_sd, loop, unroll=True,
+ALL_OPTS = [('intbounds', OptIntBounds),
+ ('rewrite', OptRewrite),
+ ('virtualize', OptVirtualize),
+ ('string', OptString),
+ ('heap', OptHeap),
+ ('ffi', OptFfiCall),
+ ('unroll', None)]
+# no direct instantiation of unroll
+
+ALL_OPTS_DICT = dict.fromkeys([name for name, _ in ALL_OPTS])
+
+ALL_OPTS_NAMES = ':'.join([name for name, _ in ALL_OPTS])
+PARAMETERS['enable_opts'] = ALL_OPTS_NAMES
+
+def optimize_loop_1(metainterp_sd, loop, enable_opts,
inline_short_preamble=True, retraced=False):
"""Optimize loop.operations to remove internal overheadish operations.
"""
- opt_str = OptString()
- optimizations = [OptIntBounds(),
- OptRewrite(),
- OptVirtualize(),
- opt_str,
- OptHeap(),
- ]
+ optimizations = []
+ unroll = 'unroll' in enable_opts
+ for name, opt in ALL_OPTS:
+ if name in enable_opts:
+ if opt is not None:
+ o = opt()
+ if unroll and name == 'string':
+ o.enabled = False
+ # FIXME: Workaround to disable string optimisation
+ # during preamble but to keep it during the loop
+ optimizations.append(o)
+
+ if 'rewrite' not in enable_opts or 'virtualize' not in enable_opts:
+ optimizations.append(OptSimplify())
+
if inline_short_preamble:
- optimizations = [OptInlineShortPreamble(retraced)] + optimizations
-
- if metainterp_sd.jit_ffi:
- from pypy.jit.metainterp.optimizeopt.fficall import OptFfiCall
- optimizations = optimizations + [
- OptFfiCall(),
- ]
+ optimizations = [OptInlineShortPreamble(retraced)] + optimizations
if unroll:
- opt_str.enabled = False # FIXME: Workaround to disable string optimisation
- # during preamble but to keep it during the loop
optimize_unroll(metainterp_sd, loop, optimizations)
else:
optimizer = Optimizer(metainterp_sd, loop, optimizations)
optimizer.propagate_all_forward()
-def optimize_bridge_1(metainterp_sd, bridge, inline_short_preamble=True,
- retraced=False):
+def optimize_bridge_1(metainterp_sd, bridge, enable_opts,
+ inline_short_preamble=True, retraced=False):
"""The same, but for a bridge. """
- optimize_loop_1(metainterp_sd, bridge, False, inline_short_preamble,
- retraced)
+ enable_opts = enable_opts.copy()
+ try:
+ del enable_opts['unroll']
+ except KeyError:
+ pass
+ optimize_loop_1(metainterp_sd, bridge, enable_opts,
+ inline_short_preamble, retraced)
diff --git a/pypy/jit/metainterp/test/test_tl.py b/pypy/jit/metainterp/test/test_tl.py
--- a/pypy/jit/metainterp/test/test_tl.py
+++ b/pypy/jit/metainterp/test/test_tl.py
@@ -1,5 +1,4 @@
import py
-from pypy.rlib.jit import OPTIMIZER_SIMPLE
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.metainterp.test.test_basic import OOJitMixin, LLJitMixin
@@ -119,7 +118,7 @@
def main(num, arg):
return interp(codes[num], inputarg=arg)
- res = self.meta_interp(main, [0, 20], optimizer=OPTIMIZER_SIMPLE,
+ res = self.meta_interp(main, [0, 20], enable_opts='',
listops=listops, backendopt=True, policy=policy)
assert res == 0
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
@@ -1275,11 +1275,6 @@
self._addr2name_keys = [key for key, value in list_of_addr2name]
self._addr2name_values = [value for key, value in list_of_addr2name]
- def setup_jitdrivers_sd(self, optimizer):
- if optimizer is not None:
- for jd in self.jitdrivers_sd:
- jd.warmstate.set_param_optimizer(optimizer)
-
def finish_setup(self, codewriter, optimizer=None):
from pypy.jit.metainterp.blackhole import BlackholeInterpBuilder
self.blackholeinterpbuilder = BlackholeInterpBuilder(codewriter, self)
@@ -1293,7 +1288,6 @@
self.jitdrivers_sd = codewriter.callcontrol.jitdrivers_sd
self.virtualref_info = codewriter.callcontrol.virtualref_info
self.callinfocollection = codewriter.callcontrol.callinfocollection
- self.setup_jitdrivers_sd(optimizer)
#
# store this information for fastpath of call_assembler
# (only the paths that can actually be taken)
diff --git a/pypy/jit/metainterp/test/test_loop_unroll.py b/pypy/jit/metainterp/test/test_loop_unroll.py
--- a/pypy/jit/metainterp/test/test_loop_unroll.py
+++ b/pypy/jit/metainterp/test/test_loop_unroll.py
@@ -1,10 +1,12 @@
import py
-from pypy.rlib.jit import OPTIMIZER_FULL
+from pypy.rlib.jit import JitDriver
from pypy.jit.metainterp.test import test_loop
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
+from pypy.jit.metainterp.optimizeopt import ALL_OPTS_NAMES
class LoopUnrollTest(test_loop.LoopTest):
- optimizer = OPTIMIZER_FULL
+ enable_opts = ALL_OPTS_NAMES
+
automatic_promotion_result = {
'int_add' : 3, 'int_gt' : 1, 'guard_false' : 1, 'jump' : 1,
}
diff --git a/pypy/jit/metainterp/warmstate.py b/pypy/jit/metainterp/warmstate.py
--- a/pypy/jit/metainterp/warmstate.py
+++ b/pypy/jit/metainterp/warmstate.py
@@ -7,8 +7,7 @@
from pypy.rlib.rarithmetic import intmask
from pypy.rlib.nonconst import NonConstant
from pypy.rlib.unroll import unrolling_iterable
-from pypy.rlib.jit import (PARAMETERS, OPTIMIZER_SIMPLE, OPTIMIZER_FULL,
- OPTIMIZER_NO_UNROLL)
+from pypy.rlib.jit import PARAMETERS
from pypy.rlib.jit import BaseJitCell
from pypy.rlib.debug import debug_start, debug_stop, debug_print
from pypy.jit.metainterp import history
@@ -224,21 +223,16 @@
def set_param_inlining(self, value):
self.inlining = value
- def set_param_optimizer(self, optimizer):
- if optimizer == OPTIMIZER_SIMPLE:
- from pypy.jit.metainterp import simple_optimize
- self.optimize_loop = simple_optimize.optimize_loop
- self.optimize_bridge = simple_optimize.optimize_bridge
- elif optimizer == OPTIMIZER_NO_UNROLL:
- from pypy.jit.metainterp import nounroll_optimize
- self.optimize_loop = nounroll_optimize.optimize_loop
- self.optimize_bridge = nounroll_optimize.optimize_bridge
- elif optimizer == OPTIMIZER_FULL:
- from pypy.jit.metainterp import optimize
- self.optimize_loop = optimize.optimize_loop
- self.optimize_bridge = optimize.optimize_bridge
- else:
- raise ValueError("unknown optimizer")
+ def set_param_enable_opts(self, value):
+ from pypy.jit.metainterp.optimizeopt import ALL_OPTS_DICT
+
+ d = {}
+ for name in value.split(":"):
+ if name:
+ if name not in ALL_OPTS_DICT:
+ raise ValueError('Unknown optimization ' + name)
+ d[name] = None
+ self.enable_opts = d
def set_param_loop_longevity(self, value):
# note: it's a global parameter, not a per-jitdriver one
@@ -294,12 +288,6 @@
"""Entry point to the JIT. Called at the point with the
can_enter_jit() hint.
"""
- if NonConstant(False):
- # make sure we always see the saner optimizer from an
- # annotation point of view, otherwise we get lots of
- # blocked ops
- self.set_param_optimizer(OPTIMIZER_FULL)
-
if vinfo is not None:
virtualizable = args[num_green_args + index_of_virtualizable]
virtualizable = vinfo.cast_to_vtype(virtualizable)
diff --git a/pypy/jit/metainterp/test/test_compile.py b/pypy/jit/metainterp/test/test_compile.py
--- a/pypy/jit/metainterp/test/test_compile.py
+++ b/pypy/jit/metainterp/test/test_compile.py
@@ -7,7 +7,7 @@
from pypy.jit.metainterp import nounroll_optimize, jitprof, typesystem, compile
from pypy.jit.metainterp.test.test_optimizeutil import LLtypeMixin
from pypy.jit.tool.oparser import parse
-
+from pypy.jit.metainterp.optimizeopt import ALL_OPTS_DICT
def test_insert_loop_token():
# XXX this test is a bit useless now that there are no specnodes
@@ -39,6 +39,7 @@
class FakeState:
optimize_loop = staticmethod(nounroll_optimize.optimize_loop)
+ enable_opts = {}
def attach_unoptimized_bridge_from_interp(*args):
pass
diff --git a/pypy/jit/metainterp/test/test_recursive.py b/pypy/jit/metainterp/test/test_recursive.py
--- a/pypy/jit/metainterp/test/test_recursive.py
+++ b/pypy/jit/metainterp/test/test_recursive.py
@@ -1,5 +1,5 @@
import py
-from pypy.rlib.jit import JitDriver, we_are_jitted, OPTIMIZER_SIMPLE, hint
+from pypy.rlib.jit import JitDriver, we_are_jitted, hint
from pypy.rlib.jit import unroll_safe, dont_look_inside
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.debug import fatalerror
@@ -25,7 +25,7 @@
return f(n+1)
else:
return 1
- res = self.meta_interp(main, [20], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(main, [20], enable_opts='')
assert res == main(20)
self.check_history(call=0)
@@ -52,7 +52,7 @@
return f(n+1)
else:
return 1
- res = self.meta_interp(main, [20], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(main, [20], enable_opts='')
assert res == main(20)
def test_recursion_three_times(self):
@@ -75,7 +75,7 @@
print
for i in range(1, 11):
print '%3d %9d' % (i, f(i))
- res = self.meta_interp(main, [10], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(main, [10], enable_opts='')
assert res == main(10)
self.check_enter_count_at_most(11)
@@ -95,7 +95,7 @@
opaque(n, i)
i += 1
return stack.pop()
- res = self.meta_interp(f, [1], optimizer=OPTIMIZER_SIMPLE, repeat=2,
+ res = self.meta_interp(f, [1], enable_opts='', repeat=2,
policy=StopAtXPolicy(opaque))
assert res == 1
@@ -142,9 +142,9 @@
codes = [code, subcode]
f = self.get_interpreter(codes)
- assert self.meta_interp(f, [0, 0, 0], optimizer=OPTIMIZER_SIMPLE) == 42
+ assert self.meta_interp(f, [0, 0, 0], enable_opts='') == 42
self.check_loops(int_add = 1, call_may_force = 1, call = 0)
- assert self.meta_interp(f, [0, 0, 0], optimizer=OPTIMIZER_SIMPLE,
+ assert self.meta_interp(f, [0, 0, 0], enable_opts='',
inline=True) == 42
self.check_loops(int_add = 2, call_may_force = 0, call = 0,
guard_no_exception = 0)
@@ -156,7 +156,7 @@
f = self.get_interpreter(codes)
- assert self.meta_interp(f, [0, 0, 0], optimizer=OPTIMIZER_SIMPLE,
+ assert self.meta_interp(f, [0, 0, 0], enable_opts='',
inline=True) == 42
# the call is fully inlined, because we jump to subcode[1], thus
# skipping completely the JUMP_BACK in subcode[0]
@@ -193,7 +193,7 @@
def main(n):
return f("c-l", n)
print main(100)
- res = self.meta_interp(main, [100], optimizer=OPTIMIZER_SIMPLE, inline=True)
+ res = self.meta_interp(main, [100], enable_opts='', inline=True)
assert res == 0
def test_guard_failure_and_then_exception_in_inlined_function(self):
@@ -234,7 +234,7 @@
def main(n):
return f("c-l", n)
print main(1000)
- res = self.meta_interp(main, [1000], optimizer=OPTIMIZER_SIMPLE, inline=True)
+ res = self.meta_interp(main, [1000], enable_opts='', inline=True)
assert res == main(1000)
def test_exception_in_inlined_function(self):
@@ -274,7 +274,7 @@
return n
def main(n):
return f("c-l", n)
- res = self.meta_interp(main, [100], optimizer=OPTIMIZER_SIMPLE, inline=True)
+ res = self.meta_interp(main, [100], enable_opts='', inline=True)
assert res == main(100)
def test_recurse_during_blackholing(self):
@@ -312,7 +312,7 @@
myjitdriver.set_param('trace_eagerness', 5)
return f("c-l", n)
expected = main(100)
- res = self.meta_interp(main, [100], optimizer=OPTIMIZER_SIMPLE, inline=True)
+ res = self.meta_interp(main, [100], enable_opts='', inline=True)
assert res == expected
def check_max_trace_length(self, length):
@@ -338,7 +338,7 @@
n -= 1
return n
TRACE_LIMIT = 66
- res = self.meta_interp(loop, [100], optimizer=OPTIMIZER_SIMPLE, inline=True, trace_limit=TRACE_LIMIT)
+ res = self.meta_interp(loop, [100], enable_opts='', inline=True, trace_limit=TRACE_LIMIT)
assert res == 0
self.check_max_trace_length(TRACE_LIMIT)
self.check_enter_count_at_most(10) # maybe
@@ -363,7 +363,7 @@
n -= 1
return n
TRACE_LIMIT = 20
- res = self.meta_interp(loop, [100], optimizer=OPTIMIZER_SIMPLE, inline=True, trace_limit=TRACE_LIMIT)
+ res = self.meta_interp(loop, [100], enable_opts='', inline=True, trace_limit=TRACE_LIMIT)
self.check_max_trace_length(TRACE_LIMIT)
self.check_aborted_count(8)
self.check_enter_count_at_most(30)
@@ -489,10 +489,10 @@
myjitdriver.set_param('inlining', False)
return loop(100)
- res = self.meta_interp(main, [0], optimizer=OPTIMIZER_SIMPLE, trace_limit=TRACE_LIMIT)
+ res = self.meta_interp(main, [0], enable_opts='', trace_limit=TRACE_LIMIT)
self.check_loops(call_may_force=1, call=0)
- res = self.meta_interp(main, [1], optimizer=OPTIMIZER_SIMPLE, trace_limit=TRACE_LIMIT)
+ res = self.meta_interp(main, [1], enable_opts='', trace_limit=TRACE_LIMIT)
self.check_loops(call_may_force=0, call=0)
def test_trace_from_start(self):
diff --git a/pypy/jit/backend/test/support.py b/pypy/jit/backend/test/support.py
--- a/pypy/jit/backend/test/support.py
+++ b/pypy/jit/backend/test/support.py
@@ -1,8 +1,8 @@
import py
import sys
from pypy.rlib.debug import debug_print
-from pypy.rlib.jit import OPTIMIZER_FULL
from pypy.translator.translator import TranslationContext, graphof
+from pypy.jit.metainterp.optimizeopt import ALL_OPTS_NAMES
class BaseCompiledMixin(object):
@@ -67,7 +67,7 @@
jd.warmstate.set_param_trace_eagerness(2) # for tests
jd.warmstate.set_param_trace_limit(trace_limit)
jd.warmstate.set_param_inlining(inline)
- jd.warmstate.set_param_optimizer(OPTIMIZER_FULL)
+ jd.warmstate.set_param_enable_opts(ALL_OPTS_NAMES)
mixlevelann = warmrunnerdesc.annhelper
entry_point_graph = mixlevelann.getgraph(entry_point, [s_list_of_strings],
annmodel.SomeInteger())
diff --git a/pypy/jit/metainterp/test/test_loop.py b/pypy/jit/metainterp/test/test_loop.py
--- a/pypy/jit/metainterp/test/test_loop.py
+++ b/pypy/jit/metainterp/test/test_loop.py
@@ -1,5 +1,5 @@
import py
-from pypy.rlib.jit import JitDriver, OPTIMIZER_SIMPLE, OPTIMIZER_FULL
+from pypy.rlib.jit import JitDriver
from pypy.rlib.objectmodel import compute_hash
from pypy.jit.metainterp.warmspot import ll_meta_interp, get_stats
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
@@ -8,14 +8,15 @@
from pypy.jit.metainterp import history
class LoopTest(object):
- optimizer = OPTIMIZER_SIMPLE
+ enable_opts = ''
+
automatic_promotion_result = {
'int_add' : 6, 'int_gt' : 1, 'guard_false' : 1, 'jump' : 1,
'guard_value' : 3
}
def meta_interp(self, f, args, policy=None):
- return ll_meta_interp(f, args, optimizer=self.optimizer,
+ return ll_meta_interp(f, args, enable_opts=self.enable_opts,
policy=policy,
CPUClass=self.CPUClass,
type_system=self.type_system)
@@ -58,7 +59,7 @@
res = self.meta_interp(f, [6, 13])
assert res == f(6, 13)
self.check_loop_count(1)
- if self.optimizer == OPTIMIZER_FULL:
+ if self.enable_opts:
self.check_loops(getfield_gc = 0, setfield_gc = 1)
def test_loop_with_two_paths(self):
@@ -87,7 +88,7 @@
return res * 2
res = self.meta_interp(f, [6, 33], policy=StopAtXPolicy(l))
assert res == f(6, 33)
- if self.optimizer == OPTIMIZER_FULL:
+ if self.enable_opts:
self.check_loop_count(3)
else:
self.check_loop_count(2)
@@ -105,7 +106,7 @@
pattern >>= 1
return 42
self.meta_interp(f, [0xF0F0F0])
- if self.optimizer == OPTIMIZER_FULL:
+ if self.enable_opts:
self.check_loop_count(3)
else:
self.check_loop_count(2)
@@ -547,7 +548,7 @@
res = self.meta_interp(f, [100, 5], policy=StopAtXPolicy(externfn))
assert res == expected
- if self.optimizer == OPTIMIZER_FULL:
+ if self.enable_opts:
self.check_loop_count(2)
self.check_tree_loop_count(2) # 1 loop, 1 bridge from interp
else:
@@ -751,7 +752,6 @@
res = self.meta_interp(f, [200])
-
class TestOOtype(LoopTest, OOJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_send_nounroll.py b/pypy/jit/metainterp/test/test_send_nounroll.py
deleted file mode 100644
--- a/pypy/jit/metainterp/test/test_send_nounroll.py
+++ /dev/null
@@ -1,30 +0,0 @@
-
-from pypy.jit.metainterp.test import test_loop, test_send
-from pypy.jit.metainterp.warmspot import ll_meta_interp
-from pypy.rlib.jit import OPTIMIZER_NO_UNROLL
-from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-
-class LoopNoPSpecTest(test_send.SendTests):
- optimizer=OPTIMIZER_NO_UNROLL
-
- def meta_interp(self, func, args, **kwds):
- return ll_meta_interp(func, args, optimizer=self.optimizer,
- CPUClass=self.CPUClass,
- type_system=self.type_system,
- **kwds)
-
- def check_loops(self, *args, **kwds):
- pass
-
- def check_loop_count(self, count):
- pass
-
- def check_jumps(self, maxcount):
- pass
-
-
-class TestLLtype(LoopNoPSpecTest, LLJitMixin):
- pass
-
-class TestOOtype(LoopNoPSpecTest, OOJitMixin):
- pass
diff --git a/pypy/jit/metainterp/test/test_send_simple.py b/pypy/jit/metainterp/test/test_send_simple.py
deleted file mode 100644
--- a/pypy/jit/metainterp/test/test_send_simple.py
+++ /dev/null
@@ -1,29 +0,0 @@
-# xxx mostly pointless
-
-from pypy.jit.metainterp.test import test_loop, test_send
-from pypy.jit.metainterp.warmspot import ll_meta_interp
-from pypy.rlib.jit import OPTIMIZER_SIMPLE
-from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-
-class LoopDummyTest(test_send.SendTests):
- optimizer=OPTIMIZER_SIMPLE
- def meta_interp(self, func, args, **kwds):
- return ll_meta_interp(func, args, optimizer=self.optimizer,
- CPUClass=self.CPUClass,
- type_system=self.type_system,
- **kwds)
-
- def check_loops(self, *args, **kwds):
- pass
-
- def check_loop_count(self, count):
- pass
-
- def check_jumps(self, maxcount):
- pass
-
-class TestLLtype(LoopDummyTest, LLJitMixin):
- pass
-
-class TestOOtype(LoopDummyTest, OOJitMixin):
- pass
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
@@ -85,6 +85,8 @@
"""Try to compile a new loop by closing the current history back
to the first operation.
"""
+ from pypy.jit.metainterp.optimize import optimize_loop
+
history = metainterp.history
loop = create_empty_loop(metainterp)
loop.inputargs = history.inputargs
@@ -105,8 +107,8 @@
loop.preamble.start_resumedescr = start_resumedescr
try:
- old_loop_token = jitdriver_sd.warmstate.optimize_loop(
- metainterp_sd, old_loop_tokens, loop)
+ old_loop_token = optimize_loop(metainterp_sd, old_loop_tokens, loop,
+ jitdriver_sd.warmstate.enable_opts)
except InvalidLoop:
return None
if old_loop_token is not None:
@@ -570,6 +572,8 @@
"""Try to compile a new bridge leading from the beginning of the history
to some existing place.
"""
+ from pypy.jit.metainterp.optimize import optimize_bridge
+
# The history contains new operations to attach as the code for the
# failure of 'resumekey.guard_op'.
#
@@ -586,10 +590,9 @@
else:
inline_short_preamble = True
try:
- target_loop_token = state.optimize_bridge(metainterp_sd,
- old_loop_tokens, new_loop,
- inline_short_preamble,
- retraced)
+ target_loop_token = optimize_bridge(metainterp_sd, old_loop_tokens,
+ new_loop, state.enable_opts,
+ inline_short_preamble, retraced)
except InvalidLoop:
# XXX I am fairly convinced that optimize_bridge cannot actually raise
# InvalidLoop
diff --git a/pypy/jit/metainterp/test/test_warmspot.py b/pypy/jit/metainterp/test/test_warmspot.py
--- a/pypy/jit/metainterp/test/test_warmspot.py
+++ b/pypy/jit/metainterp/test/test_warmspot.py
@@ -1,7 +1,7 @@
import py
from pypy.jit.metainterp.warmspot import ll_meta_interp
from pypy.jit.metainterp.warmspot import get_stats
-from pypy.rlib.jit import JitDriver, OPTIMIZER_FULL, OPTIMIZER_SIMPLE
+from pypy.rlib.jit import JitDriver
from pypy.rlib.jit import unroll_safe
from pypy.jit.backend.llgraph import runner
from pypy.jit.metainterp.history import BoxInt
diff --git a/pypy/jit/metainterp/warmspot.py b/pypy/jit/metainterp/warmspot.py
--- a/pypy/jit/metainterp/warmspot.py
+++ b/pypy/jit/metainterp/warmspot.py
@@ -25,6 +25,7 @@
from pypy.jit.metainterp.jitdriver import JitDriverStaticData
from pypy.jit.codewriter import support, codewriter, longlong
from pypy.jit.codewriter.policy import JitPolicy
+from pypy.jit.metainterp.optimizeopt import ALL_OPTS_NAMES
# ____________________________________________________________
# Bootstrapping
@@ -62,7 +63,8 @@
def jittify_and_run(interp, graph, args, repeat=1,
backendopt=False, trace_limit=sys.maxint,
- inline=False, loop_longevity=0, retrace_limit=5, **kwds):
+ inline=False, loop_longevity=0, retrace_limit=5,
+ enable_opts=ALL_OPTS_NAMES, **kwds):
from pypy.config.config import ConfigError
translator = interp.typer.annotator.translator
try:
@@ -81,6 +83,7 @@
jd.warmstate.set_param_inlining(inline)
jd.warmstate.set_param_loop_longevity(loop_longevity)
jd.warmstate.set_param_retrace_limit(retrace_limit)
+ jd.warmstate.set_param_enable_opts(enable_opts)
warmrunnerdesc.finish()
res = interp.eval_graph(graph, args)
if not kwds.get('translate_support_code', False):
@@ -145,8 +148,7 @@
class WarmRunnerDesc(object):
def __init__(self, translator, policy=None, backendopt=True, CPUClass=None,
- optimizer=None, ProfilerClass=EmptyProfiler,
- jit_ffi=None, **kwds):
+ ProfilerClass=EmptyProfiler, **kwds):
pyjitpl._warmrunnerdesc = self # this is a global for debugging only!
self.set_translator(translator)
self.memory_manager = memmgr.MemoryManager()
@@ -165,7 +167,7 @@
elif self.opt.listops:
self.prejit_optimizations_minimal_inline(policy, graphs)
- self.build_meta_interp(ProfilerClass, jit_ffi)
+ self.build_meta_interp(ProfilerClass)
self.make_args_specifications()
#
from pypy.jit.metainterp.virtualref import VirtualRefInfo
@@ -184,7 +186,7 @@
self.rewrite_set_param()
self.rewrite_force_virtual(vrefinfo)
self.add_finish()
- self.metainterp_sd.finish_setup(self.codewriter, optimizer=optimizer)
+ self.metainterp_sd.finish_setup(self.codewriter)
def finish(self):
vinfos = set([jd.virtualizable_info for jd in self.jitdrivers_sd])
@@ -283,14 +285,11 @@
translate_support_code, gcdescr=self.gcdescr)
self.cpu = cpu
- def build_meta_interp(self, ProfilerClass, jit_ffi=None):
- if jit_ffi is None:
- jit_ffi = self.translator.config.translation.jit_ffi
+ def build_meta_interp(self, ProfilerClass):
self.metainterp_sd = MetaInterpStaticData(self.cpu,
self.opt,
ProfilerClass=ProfilerClass,
- warmrunnerdesc=self,
- jit_ffi=jit_ffi)
+ warmrunnerdesc=self)
def make_virtualizable_infos(self):
vinfos = {}
@@ -786,16 +785,26 @@
annhelper = self.annhelper)
def rewrite_set_param(self):
+ from pypy.rpython.lltypesystem.rstr import STR
+
closures = {}
graphs = self.translator.graphs
_, PTR_SET_PARAM_FUNCTYPE = self.cpu.ts.get_FuncType([lltype.Signed],
lltype.Void)
- def make_closure(jd, fullfuncname):
+ _, PTR_SET_PARAM_STR_FUNCTYPE = self.cpu.ts.get_FuncType(
+ [lltype.Ptr(STR)], lltype.Void)
+ def make_closure(jd, fullfuncname, is_string):
state = jd.warmstate
def closure(i):
+ if is_string:
+ i = hlstr(i)
getattr(state, fullfuncname)(i)
- funcptr = self.helper_func(PTR_SET_PARAM_FUNCTYPE, closure)
- return Constant(funcptr, PTR_SET_PARAM_FUNCTYPE)
+ if is_string:
+ TP = PTR_SET_PARAM_STR_FUNCTYPE
+ else:
+ TP = PTR_SET_PARAM_FUNCTYPE
+ funcptr = self.helper_func(TP, closure)
+ return Constant(funcptr, TP)
#
for graph, block, i in find_set_param(graphs):
op = block.operations[i]
@@ -807,7 +816,8 @@
funcname = op.args[2].value
key = jd, funcname
if key not in closures:
- closures[key] = make_closure(jd, 'set_param_' + funcname)
+ closures[key] = make_closure(jd, 'set_param_' + funcname,
+ funcname == 'enable_opts')
op.opname = 'direct_call'
op.args[:3] = [closures[key]]
diff --git a/pypy/jit/metainterp/nounroll_optimize.py b/pypy/jit/metainterp/nounroll_optimize.py
deleted file mode 100644
--- a/pypy/jit/metainterp/nounroll_optimize.py
+++ /dev/null
@@ -1,36 +0,0 @@
-
-from pypy.rlib.debug import debug_start, debug_stop
-from pypy.jit.metainterp.optimizeopt import optimize_loop_1, optimize_bridge_1
-
-def optimize_loop(metainterp_sd, old_loop_tokens, loop):
- debug_start("jit-optimize")
- try:
- return _optimize_loop(metainterp_sd, old_loop_tokens, loop)
- finally:
- debug_stop("jit-optimize")
-
-def _optimize_loop(metainterp_sd, old_loop_tokens, loop):
- cpu = metainterp_sd.cpu
- metainterp_sd.logger_noopt.log_loop(loop.inputargs, loop.operations)
- if old_loop_tokens:
- return old_loop_tokens[0]
- optimize_loop_1(metainterp_sd, loop, False)
- return None
-
-def optimize_bridge(metainterp_sd, old_loop_tokens, bridge,
- inline_short_preamble, retraced=False):
- debug_start("jit-optimize")
- try:
- return _optimize_bridge(metainterp_sd, old_loop_tokens, bridge)
- finally:
- debug_stop("jit-optimize")
-
-def _optimize_bridge(metainterp_sd, old_loop_tokens, bridge):
- cpu = metainterp_sd.cpu
- metainterp_sd.logger_noopt.log_loop(bridge.inputargs, bridge.operations)
- if old_loop_tokens:
- old_loop_token = old_loop_tokens[0]
- bridge.operations[-1].setdescr(old_loop_token) # patch jump target
- optimize_bridge_1(metainterp_sd, bridge)
- return old_loop_token
- return None
diff --git a/pypy/jit/metainterp/test/test_slist.py b/pypy/jit/metainterp/test/test_slist.py
--- a/pypy/jit/metainterp/test/test_slist.py
+++ b/pypy/jit/metainterp/test/test_slist.py
@@ -1,8 +1,8 @@
import py
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-from pypy.rlib.jit import JitDriver, OPTIMIZER_SIMPLE
+from pypy.rlib.jit import JitDriver
-class ListTests:
+class ListTests(object):
def test_basic_list(self):
py.test.skip("not yet")
@@ -60,7 +60,7 @@
myjitdriver.jit_merge_point(n=n, lst=lst)
n -= 1
return lst[n]
- res = self.meta_interp(f, [21], listops=True, optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [21], listops=True, enable_opts='')
assert res == 0
def test_getitem(self):
diff --git a/pypy/jit/metainterp/test/test_exception.py b/pypy/jit/metainterp/test/test_exception.py
--- a/pypy/jit/metainterp/test/test_exception.py
+++ b/pypy/jit/metainterp/test/test_exception.py
@@ -1,6 +1,6 @@
import py, sys
from pypy.jit.metainterp.test.test_basic import LLJitMixin, OOJitMixin
-from pypy.rlib.jit import JitDriver, OPTIMIZER_SIMPLE, dont_look_inside
+from pypy.rlib.jit import JitDriver, dont_look_inside
from pypy.rlib.rarithmetic import ovfcheck, LONG_BIT, intmask
from pypy.jit.codewriter.policy import StopAtXPolicy
@@ -446,10 +446,10 @@
n += 1
return m
- res = self.meta_interp(f, [1, 1, 0], optimizer=OPTIMIZER_SIMPLE)
+ res = self.meta_interp(f, [1, 1, 0], enable_opts='')
assert res == f(1, 1, 0)
res = self.meta_interp(f, [809644098, 16, 0],
- optimizer=OPTIMIZER_SIMPLE)
+ enable_opts='')
assert res == f(809644098, 16, 0)
def test_int_neg_ovf(self):
@@ -470,7 +470,7 @@
return m
res = self.meta_interp(f, [-sys.maxint-1+100, 0],
- optimizer=OPTIMIZER_SIMPLE)
+ enable_opts='')
assert res == 16
def test_reraise_through_portal(self):
@@ -551,7 +551,7 @@
return 8
res = self.meta_interp(main, [41], repeat=7, policy=StopAtXPolicy(x),
- optimizer=OPTIMIZER_SIMPLE)
+ enable_opts='')
assert res == 8
def test_overflowerror_escapes(self):
More information about the Pypy-commit
mailing list