[pypy-commit] pypy default: merge
cfbolz
noreply at buildbot.pypy.org
Fri Jul 1 22:51:08 CEST 2011
Author: Carl Friedrich Bolz <cfbolz at gmx.de>
Branch:
Changeset: r45249:779dd8c23bdf
Date: 2011-07-01 22:58 +0200
http://bitbucket.org/pypy/pypy/changeset/779dd8c23bdf/
Log: merge
diff --git a/lib-python/modified-2.7/pickle.py b/lib-python/modified-2.7/pickle.py
--- a/lib-python/modified-2.7/pickle.py
+++ b/lib-python/modified-2.7/pickle.py
@@ -873,7 +873,7 @@
# Unpickling machinery
-class Unpickler:
+class Unpickler(object):
def __init__(self, file):
"""This takes a file-like object for reading a pickle data stream.
diff --git a/pypy/annotation/builtin.py b/pypy/annotation/builtin.py
--- a/pypy/annotation/builtin.py
+++ b/pypy/annotation/builtin.py
@@ -357,17 +357,6 @@
def llmemory_cast_int_to_adr(s):
return SomeAddress()
-
-##def rarith_ovfcheck(s_obj):
-## if isinstance(s_obj, SomeInteger) and s_obj.unsigned:
-## getbookkeeper().warning("ovfcheck on unsigned")
-## return s_obj
-
-##def rarith_ovfcheck_lshift(s_obj1, s_obj2):
-## if isinstance(s_obj1, SomeInteger) and s_obj1.unsigned:
-## getbookkeeper().warning("ovfcheck_lshift with unsigned")
-## return SomeInteger()
-
def unicodedata_decimal(s_uchr):
raise TypeError, "unicodedate.decimal() calls should not happen at interp-level"
@@ -385,8 +374,6 @@
original = getattr(__builtin__, name[8:])
BUILTIN_ANALYZERS[original] = value
-##BUILTIN_ANALYZERS[pypy.rlib.rarithmetic.ovfcheck] = rarith_ovfcheck
-##BUILTIN_ANALYZERS[pypy.rlib.rarithmetic.ovfcheck_lshift] = rarith_ovfcheck_lshift
BUILTIN_ANALYZERS[pypy.rlib.rarithmetic.intmask] = rarith_intmask
BUILTIN_ANALYZERS[pypy.rlib.objectmodel.instantiate] = robjmodel_instantiate
BUILTIN_ANALYZERS[pypy.rlib.objectmodel.we_are_translated] = (
diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py
--- a/pypy/interpreter/argument.py
+++ b/pypy/interpreter/argument.py
@@ -17,7 +17,7 @@
self.varargname = varargname
self.kwargname = kwargname
- @jit.purefunction
+ @jit.elidable
def find_argname(self, name):
try:
return self.argnames.index(name)
diff --git a/pypy/interpreter/function.py b/pypy/interpreter/function.py
--- a/pypy/interpreter/function.py
+++ b/pypy/interpreter/function.py
@@ -16,7 +16,7 @@
funccallunrolling = unrolling_iterable(range(4))
- at jit.purefunction_promote()
+ at jit.elidable_promote()
def _get_immutable_code(func):
assert not func.can_change_code
return func.code
@@ -63,7 +63,7 @@
if jit.we_are_jitted():
if not self.can_change_code:
return _get_immutable_code(self)
- return jit.hint(self.code, promote=True)
+ return jit.promote(self.code)
return self.code
def funccall(self, *args_w): # speed hack
diff --git a/pypy/interpreter/generator.py b/pypy/interpreter/generator.py
--- a/pypy/interpreter/generator.py
+++ b/pypy/interpreter/generator.py
@@ -62,7 +62,7 @@
raise operr
# XXX it's not clear that last_instr should be promoted at all
# but as long as it is necessary for call_assembler, let's do it early
- last_instr = jit.hint(frame.last_instr, promote=True)
+ last_instr = jit.promote(frame.last_instr)
if last_instr == -1:
if w_arg and not space.is_w(w_arg, space.w_None):
msg = "can't send non-None value to a just-started generator"
diff --git a/pypy/interpreter/test/test_typedef.py b/pypy/interpreter/test/test_typedef.py
--- a/pypy/interpreter/test/test_typedef.py
+++ b/pypy/interpreter/test/test_typedef.py
@@ -16,7 +16,7 @@
def g():
f()
-
+
try:
g()
except:
@@ -214,15 +214,6 @@
bm = A().m
assert bm.__func__ is bm.im_func
assert bm.__self__ is bm.im_self
- assert bm.im_class is A
- if '__pypy__' in sys.builtin_module_names:
- assert bm.__objclass__ is A
assert bm.__doc__ == "aaa"
assert bm.x == 3
raises(AttributeError, setattr, bm, 'x', 15)
- l = []
- assert l.append.__self__ is l
- if '__pypy__' in sys.builtin_module_names:
- assert l.append.__objclass__ is list
- assert l.__add__.__self__ is l
- assert l.__add__.__objclass__ is list
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -9,7 +9,7 @@
from pypy.interpreter.error import OperationError, operationerrfmt
from pypy.tool.sourcetools import compile2, func_with_new_name
from pypy.rlib.objectmodel import instantiate, compute_identity_hash, specialize
-from pypy.rlib.jit import hint
+from pypy.rlib.jit import promote
class TypeDef:
def __init__(self, __name, __base=None, **rawdict):
@@ -206,7 +206,7 @@
user_overridden_class = True
def getclass(self, space):
- return hint(self.w__class__, promote=True)
+ return promote(self.w__class__)
def setclass(self, space, w_subtype):
# only used by descr_set___class__
@@ -771,7 +771,6 @@
im_self = interp_attrproperty_w('w_instance', cls=Method),
__self__ = interp_attrproperty_w('w_instance', cls=Method),
im_class = interp_attrproperty_w('w_class', cls=Method),
- __objclass__ = interp_attrproperty_w('w_class', cls=Method),
__getattribute__ = interp2app(Method.descr_method_getattribute),
__eq__ = interp2app(Method.descr_method_eq),
__ne__ = descr_generic_ne,
diff --git a/pypy/jit/backend/x86/test/test_zrpy_gc.py b/pypy/jit/backend/x86/test/test_zrpy_gc.py
--- a/pypy/jit/backend/x86/test/test_zrpy_gc.py
+++ b/pypy/jit/backend/x86/test/test_zrpy_gc.py
@@ -10,7 +10,7 @@
from pypy.rlib import rgc
from pypy.rpython.lltypesystem import lltype, llmemory, rffi
from pypy.rlib.jit import JitDriver, dont_look_inside
-from pypy.rlib.jit import purefunction, unroll_safe
+from pypy.rlib.jit import elidable, unroll_safe
from pypy.jit.backend.llsupport.gc import GcLLDescr_framework
from pypy.tool.udir import udir
from pypy.config.translationoption import DEFL_GC
@@ -561,7 +561,7 @@
self.run('compile_framework_external_exception_handling')
def define_compile_framework_bug1(self):
- @purefunction
+ @elidable
def nonmoving():
x = X(1)
for i in range(7):
diff --git a/pypy/jit/backend/x86/test/test_ztranslation.py b/pypy/jit/backend/x86/test/test_ztranslation.py
--- a/pypy/jit/backend/x86/test/test_ztranslation.py
+++ b/pypy/jit/backend/x86/test/test_ztranslation.py
@@ -2,7 +2,7 @@
from pypy.tool.udir import udir
from pypy.rlib.jit import JitDriver, unroll_parameters
from pypy.rlib.jit import PARAMETERS, dont_look_inside
-from pypy.rlib.jit import hint
+from pypy.rlib.jit import promote
from pypy.jit.metainterp.jitprof import Profiler
from pypy.jit.backend.detect_cpu import getcpuclass
from pypy.jit.backend.test.support import CCompiledMixin
@@ -78,8 +78,7 @@
x = float(j)
while i > 0:
jitdriver2.jit_merge_point(i=i, res=res, func=func, x=x)
- jitdriver2.can_enter_jit(i=i, res=res, func=func, x=x)
- func = hint(func, promote=True)
+ promote(func)
argchain = ArgChain()
argchain.arg(x)
res = func.call(argchain, rffi.DOUBLE)
diff --git a/pypy/jit/codewriter/call.py b/pypy/jit/codewriter/call.py
--- a/pypy/jit/codewriter/call.py
+++ b/pypy/jit/codewriter/call.py
@@ -208,12 +208,12 @@
assert NON_VOID_ARGS == [T for T in ARGS if T is not lltype.Void]
assert RESULT == FUNC.RESULT
# ok
- # get the 'pure' and 'loopinvariant' flags from the function object
- pure = False
+ # get the 'elidable' and 'loopinvariant' flags from the function object
+ elidable = False
loopinvariant = False
if op.opname == "direct_call":
func = getattr(get_funcobj(op.args[0].value), '_callable', None)
- pure = getattr(func, "_pure_function_", False)
+ elidable = getattr(func, "_elidable_function_", False)
loopinvariant = getattr(func, "_jit_loop_invariant_", False)
if loopinvariant:
assert not NON_VOID_ARGS, ("arguments not supported for "
@@ -225,9 +225,9 @@
extraeffect = EffectInfo.EF_FORCES_VIRTUAL_OR_VIRTUALIZABLE
elif loopinvariant:
extraeffect = EffectInfo.EF_LOOPINVARIANT
- elif pure:
+ elif elidable:
# XXX check what to do about exceptions (also MemoryError?)
- extraeffect = EffectInfo.EF_PURE
+ extraeffect = EffectInfo.EF_ELIDABLE
elif self._canraise(op):
extraeffect = EffectInfo.EF_CAN_RAISE
else:
@@ -239,7 +239,7 @@
#
if oopspecindex != EffectInfo.OS_NONE:
assert effectinfo is not None
- if pure or loopinvariant:
+ if elidable or loopinvariant:
assert effectinfo is not None
assert extraeffect != EffectInfo.EF_FORCES_VIRTUAL_OR_VIRTUALIZABLE
# XXX this should also say assert not can_invalidate, but
diff --git a/pypy/jit/codewriter/effectinfo.py b/pypy/jit/codewriter/effectinfo.py
--- a/pypy/jit/codewriter/effectinfo.py
+++ b/pypy/jit/codewriter/effectinfo.py
@@ -9,7 +9,7 @@
_cache = {}
# the 'extraeffect' field is one of the following values:
- EF_PURE = 0 #pure function (and cannot raise)
+ EF_ELIDABLE = 0 #elidable function (and cannot raise)
EF_LOOPINVARIANT = 1 #special: call it only once per loop
EF_CANNOT_RAISE = 2 #a function which cannot raise
EF_CAN_RAISE = 3 #normal function (can raise)
@@ -92,7 +92,7 @@
result.readonly_descrs_fields = readonly_descrs_fields
result.readonly_descrs_arrays = readonly_descrs_arrays
if extraeffect == EffectInfo.EF_LOOPINVARIANT or \
- extraeffect == EffectInfo.EF_PURE:
+ extraeffect == EffectInfo.EF_ELIDABLE:
result.write_descrs_fields = []
result.write_descrs_arrays = []
else:
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -847,7 +847,7 @@
op1 = self.prepare_builtin_call(op, "llong_%s", args)
op2 = self._handle_oopspec_call(op1, args,
EffectInfo.OS_LLONG_%s,
- EffectInfo.EF_PURE)
+ EffectInfo.EF_ELIDABLE)
if %r == "TO_INT":
assert op2.result.concretetype == lltype.Signed
return op2
@@ -1328,13 +1328,13 @@
otherindex += EffectInfo._OS_offset_uni
self._register_extra_helper(otherindex, othername,
argtypes, resulttype,
- EffectInfo.EF_PURE)
+ EffectInfo.EF_ELIDABLE)
#
return self._handle_oopspec_call(op, args, dict[oopspec_name],
- EffectInfo.EF_PURE)
+ EffectInfo.EF_ELIDABLE)
def _handle_str2unicode_call(self, op, oopspec_name, args):
- # ll_str2unicode is not EF_PURE, because it can raise
+ # ll_str2unicode is not EF_ELIDABLE, because it can raise
# UnicodeDecodeError...
return self._handle_oopspec_call(op, args, EffectInfo.OS_STR2UNICODE)
@@ -1380,7 +1380,7 @@
def _handle_math_sqrt_call(self, op, oopspec_name, args):
return self._handle_oopspec_call(op, args, EffectInfo.OS_MATH_SQRT,
- EffectInfo.EF_PURE)
+ EffectInfo.EF_ELIDABLE)
def rewrite_op_jit_force_quasi_immutable(self, op):
v_inst, c_fieldname = op.args
diff --git a/pypy/jit/codewriter/policy.py b/pypy/jit/codewriter/policy.py
--- a/pypy/jit/codewriter/policy.py
+++ b/pypy/jit/codewriter/policy.py
@@ -35,8 +35,8 @@
def _reject_function(self, func):
if hasattr(func, '_jit_look_inside_'):
return not func._jit_look_inside_
- # explicitly pure functions are always opaque
- if getattr(func, '_pure_function_', False):
+ # explicitly elidable functions are always opaque
+ if getattr(func, '_elidable_function_', False):
return True
# pypy.rpython.module.* are opaque helpers
mod = func.__module__ or '?'
diff --git a/pypy/jit/codewriter/test/test_jtransform.py b/pypy/jit/codewriter/test/test_jtransform.py
--- a/pypy/jit/codewriter/test/test_jtransform.py
+++ b/pypy/jit/codewriter/test/test_jtransform.py
@@ -122,7 +122,7 @@
if oopspecindex == EI.OS_STR2UNICODE:
assert extraeffect == None # not pure, can raise!
else:
- assert extraeffect == EI.EF_PURE
+ assert extraeffect == EI.EF_ELIDABLE
return 'calldescr-%d' % oopspecindex
def calldescr_canraise(self, calldescr):
return False
diff --git a/pypy/jit/codewriter/test/test_policy.py b/pypy/jit/codewriter/test/test_policy.py
--- a/pypy/jit/codewriter/test/test_policy.py
+++ b/pypy/jit/codewriter/test/test_policy.py
@@ -45,8 +45,8 @@
policy.set_supports_floats(False)
assert not policy.look_inside_graph(graph)
-def test_purefunction():
- @jit.purefunction
+def test_elidable():
+ @jit.elidable
def g(x):
return x + 2
graph = support.getgraph(g, [5])
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
@@ -546,7 +546,7 @@
effectinfo = descr.get_extra_info()
if effectinfo is not None:
if effectinfo.extraeffect == EffectInfo.EF_LOOPINVARIANT or \
- effectinfo.extraeffect == EffectInfo.EF_PURE:
+ effectinfo.extraeffect == EffectInfo.EF_ELIDABLE:
return True
return False
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
@@ -1233,7 +1233,7 @@
effect = effectinfo.extraeffect
if effect == effectinfo.EF_CANNOT_RAISE:
return self.execute_varargs(rop.CALL, allboxes, descr, False)
- elif effect == effectinfo.EF_PURE:
+ elif effect == effectinfo.EF_ELIDABLE:
return self.metainterp.record_result_of_call_pure(
self.execute_varargs(rop.CALL, allboxes, descr, False))
elif effect == effectinfo.EF_LOOPINVARIANT:
diff --git a/pypy/jit/metainterp/test/test_ajit.py b/pypy/jit/metainterp/test/test_ajit.py
--- a/pypy/jit/metainterp/test/test_ajit.py
+++ b/pypy/jit/metainterp/test/test_ajit.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 loop_invariant
+from pypy.rlib.jit import loop_invariant, elidable, promote
from pypy.rlib.jit import jit_debug, assert_green, AssertGreenFailed
from pypy.rlib.jit import unroll_safe, current_trace_length
from pypy.jit.metainterp import pyjitpl, history
@@ -304,12 +304,12 @@
assert res == 42
self.check_operations_history(int_add=1, int_mul=0, call=1, guard_no_exception=0)
- def test_residual_call_pure(self):
+ def test_residual_call_elidable(self):
def externfn(x, y):
return x * y
- externfn._pure_function_ = True
+ externfn._elidable_function_ = True
def f(n):
- n = hint(n, promote=True)
+ promote(n)
return externfn(n, n+1)
res = self.interp_operations(f, [6])
assert res == 42
@@ -317,10 +317,10 @@
self.check_operations_history(int_add=0, int_mul=0,
call=0, call_pure=0)
- def test_residual_call_pure_1(self):
+ def test_residual_call_elidable_1(self):
+ @elidable
def externfn(x, y):
return x * y
- externfn._pure_function_ = True
def f(n):
return externfn(n, n+1)
res = self.interp_operations(f, [6])
@@ -329,11 +329,11 @@
self.check_operations_history(int_add=1, int_mul=0,
call=0, call_pure=1)
- def test_residual_call_pure_2(self):
+ def test_residual_call_elidable_2(self):
myjitdriver = JitDriver(greens = [], reds = ['n'])
+ @elidable
def externfn(x):
return x - 1
- externfn._pure_function_ = True
def f(n):
while n > 0:
myjitdriver.can_enter_jit(n=n)
@@ -346,11 +346,11 @@
# by optimizeopt.py
self.check_loops(int_sub=0, call=1, call_pure=0)
- def test_constfold_call_pure(self):
+ def test_constfold_call_elidable(self):
myjitdriver = JitDriver(greens = ['m'], reds = ['n'])
+ @elidable
def externfn(x):
return x - 3
- externfn._pure_function_ = True
def f(n, m):
while n > 0:
myjitdriver.can_enter_jit(n=n, m=m)
@@ -362,11 +362,11 @@
# the CALL_PURE is constant-folded away by optimizeopt.py
self.check_loops(int_sub=1, call=0, call_pure=0)
- def test_constfold_call_pure_2(self):
+ def test_constfold_call_elidable_2(self):
myjitdriver = JitDriver(greens = ['m'], reds = ['n'])
+ @elidable
def externfn(x):
return x - 3
- externfn._pure_function_ = True
class V:
def __init__(self, value):
self.value = value
@@ -382,19 +382,19 @@
# the CALL_PURE is constant-folded away by optimizeopt.py
self.check_loops(int_sub=1, call=0, call_pure=0)
- def test_pure_function_returning_object(self):
+ def test_elidable_function_returning_object(self):
myjitdriver = JitDriver(greens = ['m'], reds = ['n'])
class V:
def __init__(self, x):
self.x = x
v1 = V(1)
v2 = V(2)
+ @elidable
def externfn(x):
if x:
return v1
else:
return v2
- externfn._pure_function_ = True
def f(n, m):
while n > 0:
myjitdriver.can_enter_jit(n=n, m=m)
@@ -1252,7 +1252,7 @@
myjitdriver.jit_merge_point(x=x, l=l)
a = l[x]
x = a.g(x)
- hint(a, promote=True)
+ promote(a)
return x
res = self.meta_interp(f, [299], listops=True)
assert res == f(299)
@@ -1312,7 +1312,7 @@
x -= 5
else:
x -= 7
- hint(a, promote=True)
+ promote(a)
return x
res = self.meta_interp(f, [299], listops=True)
assert res == f(299)
@@ -1343,7 +1343,7 @@
x -= 5
else:
x -= 7
- hint(a, promote=True)
+ promote(a)
return x
res = self.meta_interp(f, [299], listops=True)
assert res == f(299)
@@ -1377,7 +1377,7 @@
x = a.g(x)
else:
x -= 7
- hint(a, promote=True)
+ promote(a)
return x
res = self.meta_interp(f, [399], listops=True)
assert res == f(399)
@@ -1496,7 +1496,7 @@
glob.a = B()
const = 2
else:
- const = hint(const, promote=True)
+ promote(const)
x -= const
res += a.x
a = None
@@ -1531,7 +1531,7 @@
myjitdriver.can_enter_jit(x=x)
myjitdriver.jit_merge_point(x=x)
a = A()
- hint(a, promote=True)
+ promote(a)
x -= 1
self.meta_interp(f, [50])
self.check_loop_count(1)
@@ -1595,9 +1595,9 @@
self.check_loops(jit_debug=2)
def test_assert_green(self):
- def f(x, promote):
- if promote:
- x = hint(x, promote=True)
+ def f(x, promote_flag):
+ if promote_flag:
+ promote(x)
assert_green(x)
return x
res = self.interp_operations(f, [8, 1])
@@ -1817,7 +1817,7 @@
while y > 0:
myjitdriver.can_enter_jit(y=y, x=x, res=res, const=const)
myjitdriver.jit_merge_point(y=y, x=x, res=res, const=const)
- const = hint(const, promote=True)
+ const = promote(const)
res = res.binop(A(const))
if y<7:
res = x
@@ -2002,7 +2002,7 @@
n = sa = 0
while n < 10:
myjitdriver.jit_merge_point(a=a, b=b, n=n, sa=sa)
- if 0 < a < hint(sys.maxint/2, promote=True): pass
+ if 0 < a < promote(sys.maxint/2): pass
if 0 < b < 100: pass
sa += (((((a << b) << b) << b) >> b) >> b) >> b
n += 1
@@ -2047,7 +2047,7 @@
n = sa = 0
while n < 10:
myjitdriver.jit_merge_point(a=a, b=b, n=n, sa=sa)
- if -hint(sys.maxint/2, promote=True) < a < 0: pass
+ if -promote(sys.maxint/2) < a < 0: pass
if 0 < b < 100: pass
sa += (((((a << b) << b) << b) >> b) >> b) >> b
n += 1
@@ -2082,7 +2082,7 @@
n = sa = 0
while n < 10:
myjitdriver.jit_merge_point(a=a, b=b, n=n, sa=sa)
- if 0 < a < hint(sys.maxint/2, promote=True): pass
+ if 0 < a < promote(sys.maxint/2): pass
if 0 < b < 100: pass
sa += (a << b) >> b
n += 1
@@ -2139,7 +2139,7 @@
if op == 'j':
j += 1
elif op == 'c':
- c = hint(c, promote=True)
+ promote(c)
c = 1 - c
elif op == '2':
if j < 3:
@@ -2208,7 +2208,8 @@
self.local_names[0] = 1
def retrieve(self):
- variables = hint(self.variables, promote=True)
+ variables = self.variables
+ promote(variables)
result = self.local_names[0]
if result == 0:
return -1
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
@@ -1,7 +1,7 @@
import py
from pypy.rlib.rarithmetic import r_singlefloat, r_longlong, r_ulonglong
-from pypy.rlib.jit import JitDriver, hint, dont_look_inside
+from pypy.rlib.jit import JitDriver, promote, dont_look_inside
from pypy.rlib.unroll import unrolling_iterable
from pypy.rlib.libffi import ArgChain, longlong2float, float2longlong
from pypy.rlib.libffi import IS_32_BIT
@@ -49,8 +49,7 @@
res = init_result
while n < 10:
driver.jit_merge_point(n=n, res=res, func=func)
- driver.can_enter_jit(n=n, res=res, func=func)
- func = hint(func, promote=True)
+ promote(func)
argchain = ArgChain()
# this loop is unrolled
for method_name, argval in method_and_args:
diff --git a/pypy/jit/metainterp/test/test_jitprof.py b/pypy/jit/metainterp/test/test_jitprof.py
--- a/pypy/jit/metainterp/test/test_jitprof.py
+++ b/pypy/jit/metainterp/test/test_jitprof.py
@@ -1,6 +1,6 @@
from pypy.jit.metainterp.warmspot import ll_meta_interp
-from pypy.rlib.jit import JitDriver, dont_look_inside, purefunction
+from pypy.rlib.jit import JitDriver, dont_look_inside, elidable
from pypy.jit.metainterp.test.support import LLJitMixin
from pypy.jit.metainterp import pyjitpl
from pypy.jit.metainterp.jitprof import *
@@ -89,7 +89,7 @@
assert profiler.calls == 1
def test_blackhole_pure(self):
- @purefunction
+ @elidable
def g(n):
return n+1
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,6 +1,6 @@
import py
from pypy.rlib.jit import JitDriver, we_are_jitted, hint
-from pypy.rlib.jit import unroll_safe, dont_look_inside
+from pypy.rlib.jit import unroll_safe, dont_look_inside, promote
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.debug import fatalerror
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin
@@ -926,7 +926,7 @@
myjitdriver.can_enter_jit(codeno=codeno, frame=frame, n=n, x=x)
myjitdriver.jit_merge_point(codeno=codeno, frame=frame, n=n,
x=x)
- frame.s = hint(frame.s, promote=True)
+ frame.s = promote(frame.s)
n -= 1
s = frame.s
assert s >= 0
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
@@ -1,5 +1,5 @@
import py
-from pypy.rlib.jit import JitDriver, hint, purefunction
+from pypy.rlib.jit import JitDriver, promote, elidable
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin
@@ -604,7 +604,7 @@
def test_constfold_pure_oosend(self):
myjitdriver = JitDriver(greens=[], reds = ['i', 'obj'])
class A:
- @purefunction
+ @elidable
def foo(self):
return 42
def fn(n, i):
@@ -613,7 +613,7 @@
while i > 0:
myjitdriver.can_enter_jit(i=i, obj=obj)
myjitdriver.jit_merge_point(i=i, obj=obj)
- obj = hint(obj, promote=True)
+ promote(obj)
res = obj.foo()
i-=1
return res
diff --git a/pypy/jit/metainterp/test/test_virtual.py b/pypy/jit/metainterp/test/test_virtual.py
--- a/pypy/jit/metainterp/test/test_virtual.py
+++ b/pypy/jit/metainterp/test/test_virtual.py
@@ -1,5 +1,5 @@
import py
-from pypy.rlib.jit import JitDriver, hint
+from pypy.rlib.jit import JitDriver, promote
from pypy.rlib.objectmodel import compute_unique_id
from pypy.jit.codewriter.policy import StopAtXPolicy
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin
@@ -300,7 +300,7 @@
while n > 0:
myjitdriver.can_enter_jit(n=n, i=i, stufflist=stufflist)
myjitdriver.jit_merge_point(n=n, i=i, stufflist=stufflist)
- i = hint(i, promote=True)
+ promote(i)
v = Stuff(i)
n -= stufflist.lst[v.x].x
return n
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,7 @@
from pypy.rpython.rclass import IR_IMMUTABLE, IR_IMMUTABLE_ARRAY
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 JitDriver, hint, dont_look_inside, promote
from pypy.rlib.rarithmetic import intmask
from pypy.jit.metainterp.test.support import LLJitMixin, OOJitMixin
from pypy.rpython.rclass import FieldListAccessor
@@ -480,7 +480,7 @@
while n > 0:
myjitdriver.can_enter_jit(frame=frame, n=n, x=x)
myjitdriver.jit_merge_point(frame=frame, n=n, x=x)
- frame.s = hint(frame.s, promote=True)
+ frame.s = promote(frame.s)
n -= 1
s = frame.s
assert s >= 0
diff --git a/pypy/jit/tl/spli/interpreter.py b/pypy/jit/tl/spli/interpreter.py
--- a/pypy/jit/tl/spli/interpreter.py
+++ b/pypy/jit/tl/spli/interpreter.py
@@ -2,7 +2,7 @@
from pypy.tool import stdlib_opcode
from pypy.jit.tl.spli import objects, pycode
from pypy.rlib.unroll import unrolling_iterable
-from pypy.rlib.jit import JitDriver, hint, dont_look_inside
+from pypy.rlib.jit import JitDriver, promote, dont_look_inside
from pypy.rlib.objectmodel import we_are_translated
opcode_method_names = stdlib_opcode.host_bytecode_spec.method_names
@@ -78,7 +78,7 @@
while True:
jitdriver.jit_merge_point(code=code, instr_index=instr_index,
frame=self)
- self.stack_depth = hint(self.stack_depth, promote=True)
+ self.stack_depth = promote(self.stack_depth)
op = ord(code[instr_index])
instr_index += 1
if op >= HAVE_ARGUMENT:
diff --git a/pypy/jit/tl/tiny2.py b/pypy/jit/tl/tiny2.py
--- a/pypy/jit/tl/tiny2.py
+++ b/pypy/jit/tl/tiny2.py
@@ -27,7 +27,7 @@
{ #1 #1 1 SUB ->#1 #1 } => when called with 5, gives '5 4 3 2 1'
"""
-from pypy.rlib.jit import hint
+from pypy.rlib.jit import hint, promote
#
# See pypy/doc/jit.txt for a higher-level overview of the JIT techniques
@@ -75,9 +75,9 @@
# ones. The JIT compiler cannot look into indirect calls, but it
# can analyze and inline the code in directly-called functions.
y = stack.pop()
- hint(y.__class__, promote=True)
+ promote(y.__class__)
x = stack.pop()
- hint(x.__class__, promote=True)
+ promote(x.__class__)
try:
z = IntBox(func_int(x.as_int(), y.as_int()))
except ValueError:
@@ -108,7 +108,7 @@
# doesn't have to worry about the 'args' list being unpredictably
# modified.
oldargs = args
- argcount = hint(len(oldargs), promote=True)
+ argcount = promote(len(oldargs))
args = []
n = 0
while n < argcount:
@@ -160,8 +160,7 @@
# read out of the 'loops' list will be a compile-time constant
# because it was pushed as a compile-time constant by the '{'
# case above into 'loops', which is a virtual list, so the
- # promotion below is just a way to make the colors match.
- pos = hint(pos, promote=True)
+ promote(pos)
else:
stack.append(StrBox(opcode))
return stack
diff --git a/pypy/jit/tl/tiny2_hotpath.py b/pypy/jit/tl/tiny2_hotpath.py
--- a/pypy/jit/tl/tiny2_hotpath.py
+++ b/pypy/jit/tl/tiny2_hotpath.py
@@ -27,7 +27,7 @@
{ #1 #1 1 SUB ->#1 #1 } => when called with 5, gives '5 4 3 2 1'
"""
-from pypy.rlib.jit import hint, JitDriver
+from pypy.rlib.jit import hint, promote, JitDriver
#
# See pypy/doc/jit.txt for a higher-level overview of the JIT techniques
@@ -77,9 +77,9 @@
# ones. The JIT compiler cannot look into indirect calls, but it
# can analyze and inline the code in directly-called functions.
stack, y = stack.pop()
- hint(y.__class__, promote=True)
+ promote(y.__class__)
stack, x = stack.pop()
- hint(x.__class__, promote=True)
+ promote(x.__class__)
try:
z = IntBox(func_int(x.as_int(), y.as_int()))
except ValueError:
@@ -120,7 +120,7 @@
# modified.
oldloops = invariants
oldargs = reds.args
- argcount = hint(len(oldargs), promote=True)
+ argcount = promote(len(oldargs))
args = []
n = 0
while n < argcount:
@@ -189,7 +189,7 @@
# because it was pushed as a compile-time constant by the '{'
# case above into 'loops', which is a virtual list, so the
# promotion below is just a way to make the colors match.
- pos = hint(pos, promote=True)
+ pos = promote(pos)
tinyjitdriver.can_enter_jit(args=args, loops=loops, stack=stack,
bytecode=bytecode, pos=pos)
else:
diff --git a/pypy/jit/tl/tiny3_hotpath.py b/pypy/jit/tl/tiny3_hotpath.py
--- a/pypy/jit/tl/tiny3_hotpath.py
+++ b/pypy/jit/tl/tiny3_hotpath.py
@@ -28,7 +28,7 @@
{ #1 #1 1 SUB ->#1 #1 } => when called with 5, gives '5 4 3 2 1'
"""
-from pypy.rlib.jit import hint, JitDriver
+from pypy.rlib.jit import promote, hint, JitDriver
from pypy.rlib.objectmodel import specialize
#
@@ -83,9 +83,9 @@
# ones. The JIT compiler cannot look into indirect calls, but it
# can analyze and inline the code in directly-called functions.
stack, y = stack.pop()
- hint(y.__class__, promote=True)
+ promote(y.__class__)
stack, x = stack.pop()
- hint(x.__class__, promote=True)
+ promote(x.__class__)
if isinstance(x, IntBox) and isinstance(y, IntBox):
z = IntBox(func_int(x.as_int(), y.as_int()))
else:
@@ -125,7 +125,7 @@
# modified.
oldloops = invariants
oldargs = reds.args
- argcount = hint(len(oldargs), promote=True)
+ argcount = promote(len(oldargs))
args = []
n = 0
while n < argcount:
@@ -194,7 +194,7 @@
# because it was pushed as a compile-time constant by the '{'
# case above into 'loops', which is a virtual list, so the
# promotion below is just a way to make the colors match.
- pos = hint(pos, promote=True)
+ pos = promote(pos)
tinyjitdriver.can_enter_jit(args=args, loops=loops, stack=stack,
bytecode=bytecode, pos=pos)
else:
diff --git a/pypy/jit/tl/tl.py b/pypy/jit/tl/tl.py
--- a/pypy/jit/tl/tl.py
+++ b/pypy/jit/tl/tl.py
@@ -2,7 +2,7 @@
import py
from pypy.jit.tl.tlopcode import *
-from pypy.rlib.jit import JitDriver, hint, dont_look_inside
+from pypy.rlib.jit import JitDriver, hint, dont_look_inside, promote
def char2int(c):
t = ord(c)
@@ -81,7 +81,7 @@
myjitdriver.jit_merge_point(pc=pc, code=code,
stack=stack, inputarg=inputarg)
opcode = ord(code[pc])
- stack.stackpos = hint(stack.stackpos, promote=True)
+ stack.stackpos = promote(stack.stackpos)
pc += 1
if opcode == NOP:
diff --git a/pypy/jit/tl/tlc.py b/pypy/jit/tl/tlc.py
--- a/pypy/jit/tl/tlc.py
+++ b/pypy/jit/tl/tlc.py
@@ -5,7 +5,7 @@
from pypy.rlib.objectmodel import specialize, we_are_translated
from pypy.jit.tl.tlopcode import *
from pypy.jit.tl import tlopcode
-from pypy.rlib.jit import JitDriver
+from pypy.rlib.jit import JitDriver, elidable
class Obj(object):
@@ -71,6 +71,7 @@
classes = [] # [(descr, cls), ...]
+ @elidable
def get(key):
for descr, cls in Class.classes:
if key.attributes == descr.attributes and\
@@ -79,7 +80,6 @@
result = Class(key)
Class.classes.append((key, result))
return result
- get._pure_function_ = True
get = staticmethod(get)
def __init__(self, descr):
diff --git a/pypy/module/_ffi/interp_ffi.py b/pypy/module/_ffi/interp_ffi.py
--- a/pypy/module/_ffi/interp_ffi.py
+++ b/pypy/module/_ffi/interp_ffi.py
@@ -235,7 +235,7 @@
argchain.arg_longlong(floatval)
def call(self, space, args_w):
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
argchain = self.build_argchain(space, args_w)
w_restype = self.w_restype
if w_restype.is_longlong():
diff --git a/pypy/module/_lsprof/interp_lsprof.py b/pypy/module/_lsprof/interp_lsprof.py
--- a/pypy/module/_lsprof/interp_lsprof.py
+++ b/pypy/module/_lsprof/interp_lsprof.py
@@ -149,7 +149,7 @@
factor * float(self.ll_it), w_sublist)
return space.wrap(w_se)
- @jit.purefunction
+ @jit.elidable
def _get_or_make_subentry(self, entry, make=True):
try:
return self.calls[entry]
@@ -167,7 +167,7 @@
self.previous = profobj.current_context
entry.recursionLevel += 1
if profobj.subcalls and self.previous:
- caller = jit.hint(self.previous.entry, promote=True)
+ caller = jit.promote(self.previous.entry)
subentry = caller._get_or_make_subentry(entry)
subentry.recursionLevel += 1
self.ll_t0 = profobj.ll_timer()
@@ -179,7 +179,7 @@
self.previous.ll_subt += tt
entry._stop(tt, it)
if profobj.subcalls and self.previous:
- caller = jit.hint(self.previous.entry, promote=True)
+ caller = jit.promote(self.previous.entry)
subentry = caller._get_or_make_subentry(entry, False)
if subentry is not None:
subentry._stop(tt, it)
@@ -282,7 +282,7 @@
c_setup_profiling()
space.getexecutioncontext().setllprofile(lsprof_call, space.wrap(self))
- @jit.purefunction
+ @jit.elidable
def _get_or_make_entry(self, f_code, make=True):
try:
return self.data[f_code]
@@ -293,7 +293,7 @@
return entry
return None
- @jit.purefunction
+ @jit.elidable
def _get_or_make_builtin_entry(self, key, make=True):
try:
return self.builtin_data[key]
@@ -306,7 +306,7 @@
def _enter_call(self, f_code):
# we have a superb gc, no point in freelist :)
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
entry = self._get_or_make_entry(f_code)
self.current_context = ProfilerContext(self, entry)
@@ -314,14 +314,14 @@
context = self.current_context
if context is None:
return
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
entry = self._get_or_make_entry(f_code, False)
if entry is not None:
context._stop(self, entry)
self.current_context = context.previous
def _enter_builtin_call(self, key):
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
entry = self._get_or_make_builtin_entry(key)
self.current_context = ProfilerContext(self, entry)
@@ -329,7 +329,7 @@
context = self.current_context
if context is None:
return
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
entry = self._get_or_make_builtin_entry(key, False)
if entry is not None:
context._stop(self, entry)
diff --git a/pypy/module/imp/importing.py b/pypy/module/imp/importing.py
--- a/pypy/module/imp/importing.py
+++ b/pypy/module/imp/importing.py
@@ -120,7 +120,7 @@
def check_sys_modules_w(space, modulename):
return space.finditem_str(space.sys.get('modules'), modulename)
- at jit.purefunction
+ at jit.elidable
def _get_dot_position(str, n):
# return the index in str of the '.' such that there are n '.'-separated
# strings after it
@@ -133,8 +133,8 @@
def _get_relative_name(space, modulename, level, w_globals):
w = space.wrap
ctxt_w_package = space.finditem_str(w_globals, '__package__')
- ctxt_w_package = jit.hint(ctxt_w_package, promote=True)
- level = jit.hint(level, promote=True)
+ ctxt_w_package = jit.promote(ctxt_w_package)
+ level = jit.promote(level)
ctxt_package = None
if ctxt_w_package is not None and ctxt_w_package is not space.w_None:
@@ -184,7 +184,7 @@
ctxt_w_name = space.finditem_str(w_globals, '__name__')
ctxt_w_path = space.finditem_str(w_globals, '__path__')
- ctxt_w_name = jit.hint(ctxt_w_name, promote=True)
+ ctxt_w_name = jit.promote(ctxt_w_name)
ctxt_name = None
if ctxt_w_name is not None:
try:
diff --git a/pypy/module/pypyjit/policy.py b/pypy/module/pypyjit/policy.py
--- a/pypy/module/pypyjit/policy.py
+++ b/pypy/module/pypyjit/policy.py
@@ -15,7 +15,7 @@
if modname in ['pypyjit', 'signal', 'micronumpy', 'math', 'exceptions',
'imp', 'sys', 'array', '_ffi', 'itertools', 'operator',
'posix', '_socket', '_sre', '_lsprof', '_weakref',
- '__pypy__']:
+ '__pypy__', 'cStringIO']:
return True
return False
diff --git a/pypy/module/signal/interp_signal.py b/pypy/module/signal/interp_signal.py
--- a/pypy/module/signal/interp_signal.py
+++ b/pypy/module/signal/interp_signal.py
@@ -80,7 +80,7 @@
pypysig_getaddr_occurred = external('pypysig_getaddr_occurred', [],
lltype.Ptr(LONG_STRUCT), _nowrapper=True,
- pure_function=True)
+ elidable_function=True)
c_alarm = external('alarm', [rffi.INT], rffi.INT)
c_pause = external('pause', [], rffi.INT)
c_siginterrupt = external('siginterrupt', [rffi.INT, rffi.INT], rffi.INT)
diff --git a/pypy/objspace/flow/operation.py b/pypy/objspace/flow/operation.py
--- a/pypy/objspace/flow/operation.py
+++ b/pypy/objspace/flow/operation.py
@@ -143,9 +143,6 @@
def mod_ovf(x, y):
return ovfcheck(x % y)
-##def pow_ovf(*two_or_three_args):
-## return ovfcheck(pow(*two_or_three_args))
-
def lshift_ovf(x, y):
return ovfcheck_lshift(x, y)
diff --git a/pypy/objspace/std/celldict.py b/pypy/objspace/std/celldict.py
--- a/pypy/objspace/std/celldict.py
+++ b/pypy/objspace/std/celldict.py
@@ -36,12 +36,12 @@
if makenew or jit.we_are_jitted():
# when we are jitting, we always go through the pure function
# below, to ensure that we have no residual dict lookup
- w_dict = jit.hint(w_dict, promote=True)
- self = jit.hint(self, promote=True)
+ w_dict = jit.promote(w_dict)
+ self = jit.promote(self)
return self._getcell_makenew(w_dict, key)
return self.unerase(w_dict.dstorage).get(key, None)
- @jit.purefunction
+ @jit.elidable
def _getcell_makenew(self, w_dict, key):
return self.unerase(w_dict.dstorage).setdefault(key, ModuleCell())
diff --git a/pypy/objspace/std/mapdict.py b/pypy/objspace/std/mapdict.py
--- a/pypy/objspace/std/mapdict.py
+++ b/pypy/objspace/std/mapdict.py
@@ -53,7 +53,7 @@
else:
return self._index_indirection(selector)
- @jit.purefunction
+ @jit.elidable
def _index_jit_pure(self, name, index):
return self._index_indirection((name, index))
@@ -113,14 +113,14 @@
def set_terminator(self, obj, terminator):
raise NotImplementedError("abstract base class")
- @jit.purefunction
+ @jit.elidable
def size_estimate(self):
return self._size_estimate >> NUM_DIGITS
def search(self, attrtype):
return None
- @jit.purefunction
+ @jit.elidable
def _get_new_attr(self, name, index):
selector = name, index
cache = self.cache_attrs
@@ -357,7 +357,7 @@
self._set_mapdict_storage_and_map(new_obj.storage, new_obj.map)
def _get_mapdict_map(self):
- return jit.hint(self.map, promote=True)
+ return jit.promote(self.map)
def _set_mapdict_map(self, map):
self.map = map
# _____________________________________________
diff --git a/pypy/objspace/std/objspace.py b/pypy/objspace/std/objspace.py
--- a/pypy/objspace/std/objspace.py
+++ b/pypy/objspace/std/objspace.py
@@ -11,7 +11,7 @@
from pypy.rlib.debug import make_sure_not_resized
from pypy.rlib.rarithmetic import base_int, widen
from pypy.rlib.objectmodel import we_are_translated
-from pypy.rlib.jit import hint
+from pypy.rlib import jit
from pypy.rlib.rbigint import rbigint
from pypy.tool.sourcetools import func_with_new_name
@@ -322,7 +322,7 @@
return W_SeqIterObject(w_obj)
def type(self, w_obj):
- hint(w_obj.__class__, promote=True)
+ jit.promote(w_obj.__class__)
return w_obj.getclass(self)
def lookup(self, w_obj, name):
diff --git a/pypy/objspace/std/typeobject.py b/pypy/objspace/std/typeobject.py
--- a/pypy/objspace/std/typeobject.py
+++ b/pypy/objspace/std/typeobject.py
@@ -9,8 +9,8 @@
from pypy.objspace.std.objecttype import object_typedef
from pypy.rlib.objectmodel import we_are_translated
from pypy.rlib.objectmodel import current_object_addr_as_int, compute_hash
-from pypy.rlib.jit import hint, purefunction_promote, we_are_jitted
-from pypy.rlib.jit import purefunction, dont_look_inside, unroll_safe
+from pypy.rlib.jit import promote, elidable_promote, we_are_jitted
+from pypy.rlib.jit import elidable, dont_look_inside, unroll_safe
from pypy.rlib.rarithmetic import intmask, r_uint
class TypeCell(W_Root):
@@ -177,7 +177,7 @@
# prebuilt objects cannot get their version_tag changed
return w_self._pure_version_tag()
- @purefunction_promote()
+ @elidable_promote()
def _pure_version_tag(w_self):
return w_self._version_tag
@@ -247,7 +247,7 @@
return w_value
return w_value
- @purefunction
+ @elidable
def _pure_getdictvalue_no_unwrapping(w_self, space, version_tag, attr):
return w_self._getdictvalue_no_unwrapping(space, attr)
@@ -351,16 +351,16 @@
def lookup_where_with_method_cache(w_self, name):
space = w_self.space
- w_self = hint(w_self, promote=True)
+ promote(w_self)
assert space.config.objspace.std.withmethodcache
- version_tag = hint(w_self.version_tag(), promote=True)
+ version_tag = promote(w_self.version_tag())
if version_tag is None:
tup = w_self._lookup_where(name)
return tup
w_class, w_value = w_self._pure_lookup_where_with_method_cache(name, version_tag)
return w_class, unwrap_cell(space, w_value)
- @purefunction
+ @elidable
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
cache = space.fromcache(MethodCache)
@@ -450,8 +450,8 @@
w_self.flag_abstract = bool(abstract)
def issubtype(w_self, w_type):
- w_self = hint(w_self, promote=True)
- w_type = hint(w_type, promote=True)
+ promote(w_self)
+ promote(w_type)
if w_self.space.config.objspace.std.withtypeversion and we_are_jitted():
version_tag1 = w_self.version_tag()
version_tag2 = w_type.version_tag()
@@ -777,7 +777,7 @@
# ____________________________________________________________
def call__Type(space, w_type, __args__):
- w_type = hint(w_type, promote=True)
+ promote(w_type)
# special case for type(x)
if space.is_w(w_type, space.w_type):
try:
@@ -823,7 +823,7 @@
def _issubtype(w_sub, w_type):
return w_type in w_sub.mro_w
- at purefunction_promote()
+ at elidable_promote()
def _pure_issubtype(w_sub, w_type, version_tag1, version_tag2):
return _issubtype(w_sub, w_type)
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -6,21 +6,26 @@
from pypy.rlib.unroll import unrolling_iterable
from pypy.rlib.nonconst import NonConstant
-def purefunction(func):
- """ Decorate a function as pure. Pure means precisely that:
+def elidable(func):
+ """ Decorate a function as "trace-elidable". This means precisely that:
(1) the result of the call should not change if the arguments are
the same (same numbers or same pointers)
(2) it's fine to remove the call completely if we can guess the result
according to rule 1
- Most importantly it doesn't mean that pure function has no observable
- side effect, but those side effects can be ommited (ie caching).
+ Most importantly it doesn't mean that an elidable function has no observable
+ side effect, but those side effects are idempotent (ie caching).
For now, such a function should never raise an exception.
"""
- func._pure_function_ = True
+ func._elidable_function_ = True
return func
+def purefunction(*args, **kwargs):
+ import warnings
+ warnings.warn("purefunction is deprecated, use elidable instead", DeprecationWarning)
+ return elidable(*args, **kwargs)
+
def hint(x, **kwds):
""" Hint for the JIT
@@ -36,6 +41,10 @@
"""
return x
+ at specialize.argtype(0)
+def promote(x):
+ return hint(x, promote=True)
+
def dont_look_inside(func):
""" Make sure the JIT does not trace inside decorated function
(it becomes a call instead)
@@ -60,13 +69,13 @@
func._jit_loop_invariant_ = True
return func
-def purefunction_promote(promote_args='all'):
+def elidable_promote(promote_args='all'):
""" A decorator that promotes all arguments and then calls the supplied
function
"""
def decorator(func):
import inspect
- purefunction(func)
+ elidable(func)
args, varargs, varkw, defaults = inspect.getargspec(func)
args = ["v%s" % (i, ) for i in range(len(args))]
assert varargs is None and varkw is None
@@ -85,6 +94,12 @@
return result
return decorator
+def purefunction_promote(*args, **kwargs):
+ import warnings
+ warnings.warn("purefunction_promote is deprecated, use elidable_promote instead", DeprecationWarning)
+ return elidable_promote(*args, **kwargs)
+
+
def oopspec(spec):
def decorator(func):
func.oopspec = spec
diff --git a/pypy/rlib/libffi.py b/pypy/rlib/libffi.py
--- a/pypy/rlib/libffi.py
+++ b/pypy/rlib/libffi.py
@@ -40,7 +40,7 @@
del cls._import
@staticmethod
- @jit.purefunction
+ @jit.elidable
def getkind(ffi_type):
"""Returns 'v' for void, 'f' for float, 'i' for signed integer,
and 'u' for unsigned integer.
@@ -74,7 +74,7 @@
raise KeyError
@staticmethod
- @jit.purefunction
+ @jit.elidable
def is_struct(ffi_type):
return intmask(ffi_type.c_type) == intmask(FFI_TYPE_STRUCT)
@@ -253,7 +253,7 @@
# the optimizer will fail to recognize the pattern and won't turn it
# into a fast CALL. Note that "arg = arg.next" is optimized away,
# assuming that archain is completely virtual.
- self = jit.hint(self, promote=True)
+ self = jit.promote(self)
if argchain.numargs != len(self.argtypes):
raise TypeError, 'Wrong number of arguments: %d expected, got %d' %\
(argchain.numargs, len(self.argtypes))
diff --git a/pypy/rlib/longlong2float.py b/pypy/rlib/longlong2float.py
--- a/pypy/rlib/longlong2float.py
+++ b/pypy/rlib/longlong2float.py
@@ -49,9 +49,9 @@
longlong2float = rffi.llexternal(
"pypy__longlong2float", [rffi.LONGLONG], rffi.DOUBLE,
_callable=longlong2float_emulator, compilation_info=eci,
- _nowrapper=True, pure_function=True)
+ _nowrapper=True, elidable_function=True)
float2longlong = rffi.llexternal(
"pypy__float2longlong", [rffi.DOUBLE], rffi.LONGLONG,
_callable=float2longlong_emulator, compilation_info=eci,
- _nowrapper=True, pure_function=True)
+ _nowrapper=True, elidable_function=True)
diff --git a/pypy/rlib/rbigint.py b/pypy/rlib/rbigint.py
--- a/pypy/rlib/rbigint.py
+++ b/pypy/rlib/rbigint.py
@@ -124,7 +124,7 @@
return len(self._digits)
@staticmethod
- @jit.purefunction
+ @jit.elidable
def fromint(intval):
# This function is marked as pure, so you must not call it and
# then modify the result.
@@ -156,7 +156,7 @@
return v
@staticmethod
- @jit.purefunction
+ @jit.elidable
def frombool(b):
# This function is marked as pure, so you must not call it and
# then modify the result.
@@ -179,7 +179,7 @@
raise OverflowError
@staticmethod
- @jit.purefunction
+ @jit.elidable
def _fromfloat_finite(dval):
sign = 1
if dval < 0.0:
@@ -201,7 +201,7 @@
return v
@staticmethod
- @jit.purefunction
+ @jit.elidable
@specialize.argtype(0)
def fromrarith_int(i):
# This function is marked as pure, so you must not call it and
@@ -209,7 +209,7 @@
return rbigint(*args_from_rarith_int(i))
@staticmethod
- @jit.purefunction
+ @jit.elidable
def fromdecimalstr(s):
# This function is marked as pure, so you must not call it and
# then modify the result.
diff --git a/pypy/rlib/rmd5.py b/pypy/rlib/rmd5.py
--- a/pypy/rlib/rmd5.py
+++ b/pypy/rlib/rmd5.py
@@ -51,7 +51,7 @@
_rotateLeft = rffi.llexternal(
"pypy__rotateLeft", [lltype.Unsigned, lltype.Signed], lltype.Unsigned,
_callable=_rotateLeft_emulator, compilation_info=eci,
- _nowrapper=True, pure_function=True)
+ _nowrapper=True, elidable_function=True)
# we expect the function _rotateLeft to be actually inlined
diff --git a/pypy/rlib/test/test_jit.py b/pypy/rlib/test/test_jit.py
--- a/pypy/rlib/test/test_jit.py
+++ b/pypy/rlib/test/test_jit.py
@@ -1,6 +1,6 @@
import py
from pypy.conftest import option
-from pypy.rlib.jit import hint, we_are_jitted, JitDriver, purefunction_promote
+from pypy.rlib.jit import hint, we_are_jitted, JitDriver, elidable_promote
from pypy.rlib.jit import JitHintError, oopspec
from pypy.translator.translator import TranslationContext, graphof
from pypy.rpython.test.tool import BaseRtypingTest, LLRtypeMixin, OORtypeMixin
@@ -31,8 +31,8 @@
res = self.interpret(f, [4])
assert res == 5
- def test_purefunction_promote(self):
- @purefunction_promote()
+ def test_elidable_promote(self):
+ @elidable_promote()
def g(func):
return func + 1
def f(x):
@@ -40,8 +40,8 @@
res = self.interpret(f, [2])
assert res == 5
- def test_purefunction_promote_args(self):
- @purefunction_promote(promote_args='0')
+ def test_elidable_promote_args(self):
+ @elidable_promote(promote_args='0')
def g(func, x):
return func + 1
def f(x):
diff --git a/pypy/rpython/lltypesystem/ll_str.py b/pypy/rpython/lltypesystem/ll_str.py
--- a/pypy/rpython/lltypesystem/ll_str.py
+++ b/pypy/rpython/lltypesystem/ll_str.py
@@ -1,12 +1,13 @@
from pypy.rpython.lltypesystem.lltype import GcArray, Array, Char, malloc
from pypy.rpython.annlowlevel import llstr
from pypy.rlib.rarithmetic import r_uint, r_longlong, r_ulonglong
+from pypy.rlib import jit
CHAR_ARRAY = GcArray(Char)
+ at jit.elidable
def ll_int_str(repr, i):
return ll_int2dec(i)
-ll_int_str._pure_function_ = True
def ll_unsigned(i):
if isinstance(i, r_longlong) or isinstance(i, r_ulonglong):
@@ -14,6 +15,7 @@
else:
return r_uint(i)
+ at jit.elidable
def ll_int2dec(i):
from pypy.rpython.lltypesystem.rstr import mallocstr
temp = malloc(CHAR_ARRAY, 20)
@@ -44,13 +46,13 @@
result.chars[j] = temp[len-j-1]
j += 1
return result
-ll_int2dec._pure_function_ = True
hex_chars = malloc(Array(Char), 16, immortal=True)
for i in range(16):
hex_chars[i] = "%x"%i
+ at jit.elidable
def ll_int2hex(i, addPrefix):
from pypy.rpython.lltypesystem.rstr import mallocstr
temp = malloc(CHAR_ARRAY, 20)
@@ -86,8 +88,8 @@
result.chars[j] = temp[len-j-1]
j += 1
return result
-ll_int2hex._pure_function_ = True
+ at jit.elidable
def ll_int2oct(i, addPrefix):
from pypy.rpython.lltypesystem.rstr import mallocstr
if i == 0:
@@ -123,9 +125,8 @@
result.chars[j] = temp[len-j-1]
j += 1
return result
-ll_int2oct._pure_function_ = True
+ at jit.elidable
def ll_float_str(repr, f):
from pypy.rlib.rfloat import formatd
return llstr(formatd(f, 'f', 6))
-ll_float_str._pure_function_ = True
diff --git a/pypy/rpython/lltypesystem/module/ll_math.py b/pypy/rpython/lltypesystem/module/ll_math.py
--- a/pypy/rpython/lltypesystem/module/ll_math.py
+++ b/pypy/rpython/lltypesystem/module/ll_math.py
@@ -58,7 +58,7 @@
math_log10 = llexternal('log10', [rffi.DOUBLE], rffi.DOUBLE)
math_copysign = llexternal(underscore + 'copysign',
[rffi.DOUBLE, rffi.DOUBLE], rffi.DOUBLE,
- pure_function=True)
+ elidable_function=True)
math_atan2 = llexternal('atan2', [rffi.DOUBLE, rffi.DOUBLE], rffi.DOUBLE)
math_frexp = llexternal('frexp', [rffi.DOUBLE, rffi.INTP], rffi.DOUBLE)
math_modf = llexternal('modf', [rffi.DOUBLE, rffi.DOUBLEP], rffi.DOUBLE)
@@ -67,11 +67,11 @@
math_fmod = llexternal('fmod', [rffi.DOUBLE, rffi.DOUBLE], rffi.DOUBLE)
math_hypot = llexternal(underscore + 'hypot',
[rffi.DOUBLE, rffi.DOUBLE], rffi.DOUBLE)
-math_floor = llexternal('floor', [rffi.DOUBLE], rffi.DOUBLE, pure_function=True)
+math_floor = llexternal('floor', [rffi.DOUBLE], rffi.DOUBLE, elidable_function=True)
math_sqrt = llexternal('sqrt', [rffi.DOUBLE], rffi.DOUBLE)
- at jit.purefunction
+ at jit.elidable
def sqrt_nonneg(x):
return math_sqrt(x)
sqrt_nonneg.oopspec = "math.sqrt_nonneg(x)"
diff --git a/pypy/rpython/lltypesystem/rdict.py b/pypy/rpython/lltypesystem/rdict.py
--- a/pypy/rpython/lltypesystem/rdict.py
+++ b/pypy/rpython/lltypesystem/rdict.py
@@ -845,10 +845,16 @@
POPITEMINDEX = lltype.Struct('PopItemIndex', ('nextindex', lltype.Signed))
global_popitem_index = lltype.malloc(POPITEMINDEX, zero=True, immortal=True)
-def ll_popitem(ELEM, dic):
+def _ll_getnextitem(dic):
entries = dic.entries
+ ENTRY = lltype.typeOf(entries).TO.OF
dmask = len(entries) - 1
- base = global_popitem_index.nextindex
+ if hasattr(ENTRY, 'f_hash'):
+ if entries.valid(0):
+ return 0
+ base = entries[0].f_hash
+ else:
+ base = global_popitem_index.nextindex
counter = 0
while counter <= dmask:
i = (base + counter) & dmask
@@ -857,8 +863,16 @@
break
else:
raise KeyError
- global_popitem_index.nextindex += counter
- entry = entries[i]
+ if hasattr(ENTRY, 'f_hash'):
+ entries[0].f_hash = base + counter
+ else:
+ global_popitem_index.nextindex = base + counter
+ return i
+
+ at jit.dont_look_inside
+def ll_popitem(ELEM, dic):
+ i = _ll_getnextitem(dic)
+ entry = dic.entries[i]
r = lltype.malloc(ELEM.TO)
r.item0 = recast(ELEM.TO.item0, entry.key)
r.item1 = recast(ELEM.TO.item1, entry.value)
diff --git a/pypy/rpython/lltypesystem/rffi.py b/pypy/rpython/lltypesystem/rffi.py
--- a/pypy/rpython/lltypesystem/rffi.py
+++ b/pypy/rpython/lltypesystem/rffi.py
@@ -55,7 +55,7 @@
compilation_info=ExternalCompilationInfo(),
sandboxsafe=False, threadsafe='auto',
_nowrapper=False, calling_conv='c',
- oo_primitive=None, pure_function=False,
+ oo_primitive=None, elidable_function=False,
macro=None):
"""Build an external function that will invoke the C function 'name'
with the given 'args' types and 'result' type.
@@ -87,8 +87,8 @@
name, macro, ext_type, compilation_info)
else:
_callable = ll2ctypes.LL2CtypesCallable(ext_type, calling_conv)
- if pure_function:
- _callable._pure_function_ = True
+ if elidable_function:
+ _callable._elidable_function_ = True
kwds = {}
if oo_primitive:
kwds['oo_primitive'] = oo_primitive
diff --git a/pypy/rpython/lltypesystem/rstr.py b/pypy/rpython/lltypesystem/rstr.py
--- a/pypy/rpython/lltypesystem/rstr.py
+++ b/pypy/rpython/lltypesystem/rstr.py
@@ -4,7 +4,7 @@
from pypy.rlib.objectmodel import malloc_zero_filled, we_are_translated
from pypy.rlib.objectmodel import _hash_string, enforceargs
from pypy.rlib.debug import ll_assert
-from pypy.rlib.jit import purefunction, we_are_jitted, dont_look_inside
+from pypy.rlib.jit import elidable, we_are_jitted, dont_look_inside
from pypy.rlib.rarithmetic import ovfcheck
from pypy.rpython.robject import PyObjRepr, pyobj_repr
from pypy.rpython.rmodel import inputconst, IntegerRepr
@@ -144,7 +144,7 @@
self.ll = LLHelpers
self.malloc = mallocunicode
- @purefunction
+ @elidable
def ll_str(self, s):
# XXX crazy that this is here, but I don't want to break
# rmodel logic
@@ -159,7 +159,7 @@
result.chars[i] = cast_primitive(Char, c)
return result
- @purefunction
+ @elidable
def ll_encode_latin1(self, s):
length = len(s.chars)
result = mallocstr(length)
@@ -258,7 +258,7 @@
class LLHelpers(AbstractLLHelpers):
- @purefunction
+ @elidable
def ll_str_mul(s, times):
if times < 0:
times = 0
@@ -280,7 +280,7 @@
i += j
return newstr
- @purefunction
+ @elidable
def ll_char_mul(ch, times):
if typeOf(ch) is Char:
malloc = mallocstr
@@ -325,8 +325,7 @@
return s
ll_str2unicode.oopspec = 'str.str2unicode(str)'
- # it's pure but it does not look like it
- @purefunction
+ @elidable
def ll_strhash(s):
# unlike CPython, there is no reason to avoid to return -1
# but our malloc initializes the memory to zero, so we use zero as the
@@ -342,7 +341,7 @@
def ll_strfasthash(s):
return s.hash # assumes that the hash is already computed
- @purefunction
+ @elidable
def ll_strconcat(s1, s2):
len1 = len(s1.chars)
len2 = len(s2.chars)
@@ -352,7 +351,7 @@
return newstr
ll_strconcat.oopspec = 'stroruni.concat(s1, s2)'
- @purefunction
+ @elidable
def ll_strip(s, ch, left, right):
s_len = len(s.chars)
if s_len == 0:
@@ -370,7 +369,7 @@
s.copy_contents(s, result, lpos, 0, r_len)
return result
- @purefunction
+ @elidable
def ll_upper(s):
s_chars = s.chars
s_len = len(s_chars)
@@ -387,7 +386,7 @@
i += 1
return result
- @purefunction
+ @elidable
def ll_lower(s):
s_chars = s.chars
s_len = len(s_chars)
@@ -428,7 +427,7 @@
i += 1
return result
- @purefunction
+ @elidable
def ll_strcmp(s1, s2):
if not s1 and not s2:
return True
@@ -451,7 +450,7 @@
i += 1
return len1 - len2
- @purefunction
+ @elidable
def ll_streq(s1, s2):
if s1 == s2: # also if both are NULLs
return True
@@ -471,7 +470,7 @@
return True
ll_streq.oopspec = 'stroruni.equal(s1, s2)'
- @purefunction
+ @elidable
def ll_startswith(s1, s2):
len1 = len(s1.chars)
len2 = len(s2.chars)
@@ -487,7 +486,7 @@
return True
- @purefunction
+ @elidable
def ll_endswith(s1, s2):
len1 = len(s1.chars)
len2 = len(s2.chars)
@@ -504,7 +503,7 @@
return True
- @purefunction
+ @elidable
def ll_find_char(s, ch, start, end):
i = start
if end > len(s.chars):
@@ -516,7 +515,7 @@
return -1
ll_find_char._annenforceargs_ = [None, None, int, int]
- @purefunction
+ @elidable
def ll_rfind_char(s, ch, start, end):
if end > len(s.chars):
end = len(s.chars)
@@ -527,7 +526,7 @@
return i
return -1
- @purefunction
+ @elidable
def ll_count_char(s, ch, start, end):
count = 0
i = start
@@ -595,7 +594,7 @@
res = 0
return res
- @purefunction
+ @elidable
def ll_search(s1, s2, start, end, mode):
count = 0
n = end - start
@@ -718,7 +717,7 @@
i += 1
return result
- @purefunction
+ @elidable
def _ll_stringslice(s1, start, stop):
lgt = stop - start
assert start >= 0
@@ -816,7 +815,7 @@
item.copy_contents(s, item, j, 0, i - j)
return res
- @purefunction
+ @elidable
def ll_replace_chr_chr(s, c1, c2):
length = len(s.chars)
newstr = s.malloc(length)
@@ -831,7 +830,7 @@
j += 1
return newstr
- @purefunction
+ @elidable
def ll_contains(s, c):
chars = s.chars
strlen = len(chars)
@@ -842,7 +841,7 @@
i += 1
return False
- @purefunction
+ @elidable
def ll_int(s, base):
if not 2 <= base <= 36:
raise ValueError
diff --git a/pypy/rpython/test/test_rdict.py b/pypy/rpython/test/test_rdict.py
--- a/pypy/rpython/test/test_rdict.py
+++ b/pypy/rpython/test/test_rdict.py
@@ -598,6 +598,30 @@
res = self.interpret(func, [])
assert res in [5263, 6352]
+ def test_dict_popitem_hash(self):
+ def deq(n, m):
+ return n == m
+ def dhash(n):
+ return ~n
+ def func():
+ d = r_dict(deq, dhash)
+ d[5] = 2
+ d[6] = 3
+ k1, v1 = d.popitem()
+ assert len(d) == 1
+ k2, v2 = d.popitem()
+ try:
+ d.popitem()
+ except KeyError:
+ pass
+ else:
+ assert 0, "should have raised KeyError"
+ assert len(d) == 0
+ return k1*1000 + v1*100 + k2*10 + v2
+
+ res = self.interpret(func, [])
+ assert res in [5263, 6352]
+
class TestLLtype(BaseTestRdict, LLRtypeMixin):
def test_dict_but_not_with_char_keys(self):
def func(i):
More information about the pypy-commit
mailing list