[pypy-commit] pypy inline-dict-ops: merge default
fijal
noreply at buildbot.pypy.org
Fri Jul 8 15:36:39 CEST 2011
Author: Maciej Fijalkowski <fijall at gmail.com>
Branch: inline-dict-ops
Changeset: r45419:f152b2c48f65
Date: 2011-07-08 15:45 +0200
http://bitbucket.org/pypy/pypy/changeset/f152b2c48f65/
Log: merge default
diff --git a/.hgignore b/.hgignore
--- a/.hgignore
+++ b/.hgignore
@@ -1,6 +1,7 @@
syntax: glob
*.py[co]
*~
+.*.swp
syntax: regexp
^testresult$
@@ -38,6 +39,8 @@
^pypy/translator/benchmark/shootout_benchmarks$
^pypy/translator/goal/pypy-translation-snapshot$
^pypy/translator/goal/pypy-c
+^pypy/translator/goal/pypy-jvm
+^pypy/translator/goal/pypy-jvm.jar
^pypy/translator/goal/.+\.exe$
^pypy/translator/goal/.+\.dll$
^pypy/translator/goal/target.+-c$
diff --git a/lib-python/modified-2.7/distutils/cygwinccompiler.py b/lib-python/modified-2.7/distutils/cygwinccompiler.py
--- a/lib-python/modified-2.7/distutils/cygwinccompiler.py
+++ b/lib-python/modified-2.7/distutils/cygwinccompiler.py
@@ -75,6 +75,9 @@
elif msc_ver == '1500':
# VS2008 / MSVC 9.0
return ['msvcr90']
+ elif msc_ver == '1600':
+ # VS2010 / MSVC 10.0
+ return ['msvcr100']
else:
raise ValueError("Unknown MS Compiler version %s " % msc_ver)
diff --git a/lib-python/modified-2.7/opcode.py b/lib-python/modified-2.7/opcode.py
--- a/lib-python/modified-2.7/opcode.py
+++ b/lib-python/modified-2.7/opcode.py
@@ -189,7 +189,6 @@
def_op('MAP_ADD', 147)
# pypy modification, experimental bytecode
-def_op('CALL_LIKELY_BUILTIN', 200) # #args + (#kwargs << 8)
def_op('LOOKUP_METHOD', 201) # Index in name list
hasname.append(201)
def_op('CALL_METHOD', 202) # #args not including 'self'
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/lib-python/modified-2.7/test/test_descr.py b/lib-python/modified-2.7/test/test_descr.py
--- a/lib-python/modified-2.7/test/test_descr.py
+++ b/lib-python/modified-2.7/test/test_descr.py
@@ -4400,7 +4400,10 @@
self.assertTrue(l.__add__ != l.__mul__)
self.assertTrue(l.__add__.__name__ == '__add__')
self.assertTrue(l.__add__.__self__ is l)
- self.assertTrue(l.__add__.__objclass__ is list)
+ if hasattr(l.__add__, '__objclass__'): # CPython
+ self.assertTrue(l.__add__.__objclass__ is list)
+ else: # PyPy
+ self.assertTrue(l.__add__.im_class is list)
self.assertEqual(l.__add__.__doc__, list.__add__.__doc__)
try:
hash(l.__add__)
diff --git a/lib-python/modified-2.7/test/test_dis.py b/lib-python/modified-2.7/test/test_dis.py
deleted file mode 100644
--- a/lib-python/modified-2.7/test/test_dis.py
+++ /dev/null
@@ -1,152 +0,0 @@
-# Minimal tests for dis module
-
-from test.test_support import run_unittest
-import unittest
-import sys
-import dis
-import StringIO
-
-
-def _f(a):
- print a
- return 1
-
-dis_f = """\
- %-4d 0 LOAD_FAST 0 (a)
- 3 PRINT_ITEM
- 4 PRINT_NEWLINE
-
- %-4d 5 LOAD_CONST 1 (1)
- 8 RETURN_VALUE
-"""%(_f.func_code.co_firstlineno + 1,
- _f.func_code.co_firstlineno + 2)
-
-
-# we "call" rangexxx() instead of range() to disable the
-# pypy optimization that turns it into CALL_LIKELY_BUILTIN.
-def bug708901():
- for res in rangexxx(1,
- 10):
- pass
-
-dis_bug708901 = """\
- %-4d 0 SETUP_LOOP 23 (to 26)
- 3 LOAD_GLOBAL 0 (rangexxx)
- 6 LOAD_CONST 1 (1)
-
- %-4d 9 LOAD_CONST 2 (10)
- 12 CALL_FUNCTION 2
- 15 GET_ITER
- >> 16 FOR_ITER 6 (to 25)
- 19 STORE_FAST 0 (res)
-
- %-4d 22 JUMP_ABSOLUTE 16
- >> 25 POP_BLOCK
- >> 26 LOAD_CONST 0 (None)
- 29 RETURN_VALUE
-"""%(bug708901.func_code.co_firstlineno + 1,
- bug708901.func_code.co_firstlineno + 2,
- bug708901.func_code.co_firstlineno + 3)
-
-
-def bug1333982(x=[]):
- assert 0, ([s for s in x] +
- 1)
- pass
-
-dis_bug1333982 = """\
- %-4d 0 LOAD_CONST 1 (0)
- 3 POP_JUMP_IF_TRUE 38
- 6 LOAD_GLOBAL 0 (AssertionError)
- 9 BUILD_LIST 0
- 12 LOAD_FAST 0 (x)
- 15 GET_ITER
- >> 16 FOR_ITER 12 (to 31)
- 19 STORE_FAST 1 (s)
- 22 LOAD_FAST 1 (s)
- 25 LIST_APPEND 2
- 28 JUMP_ABSOLUTE 16
-
- %-4d >> 31 LOAD_CONST 2 (1)
- 34 BINARY_ADD
- 35 RAISE_VARARGS 2
-
- %-4d >> 38 LOAD_CONST 0 (None)
- 41 RETURN_VALUE
-"""%(bug1333982.func_code.co_firstlineno + 1,
- bug1333982.func_code.co_firstlineno + 2,
- bug1333982.func_code.co_firstlineno + 3)
-
-_BIG_LINENO_FORMAT = """\
-%3d 0 LOAD_GLOBAL 0 (spam)
- 3 POP_TOP
- 4 LOAD_CONST 0 (None)
- 7 RETURN_VALUE
-"""
-
-class DisTests(unittest.TestCase):
- def do_disassembly_test(self, func, expected):
- s = StringIO.StringIO()
- save_stdout = sys.stdout
- sys.stdout = s
- dis.dis(func)
- sys.stdout = save_stdout
- got = s.getvalue()
- # Trim trailing blanks (if any).
- lines = got.split('\n')
- lines = [line.rstrip() for line in lines]
- expected = expected.split("\n")
- import difflib
- if expected != lines:
- self.fail(
- "events did not match expectation:\n" +
- "\n".join(difflib.ndiff(expected,
- lines)))
-
- def test_opmap(self):
- self.assertEqual(dis.opmap["STOP_CODE"], 0)
- self.assertIn(dis.opmap["LOAD_CONST"], dis.hasconst)
- self.assertIn(dis.opmap["STORE_NAME"], dis.hasname)
-
- def test_opname(self):
- self.assertEqual(dis.opname[dis.opmap["LOAD_FAST"]], "LOAD_FAST")
-
- def test_boundaries(self):
- self.assertEqual(dis.opmap["EXTENDED_ARG"], dis.EXTENDED_ARG)
- self.assertEqual(dis.opmap["STORE_NAME"], dis.HAVE_ARGUMENT)
-
- def test_dis(self):
- self.do_disassembly_test(_f, dis_f)
-
- def test_bug_708901(self):
- self.do_disassembly_test(bug708901, dis_bug708901)
-
- def test_bug_1333982(self):
- # This one is checking bytecodes generated for an `assert` statement,
- # so fails if the tests are run with -O. Skip this test then.
- if __debug__:
- self.do_disassembly_test(bug1333982, dis_bug1333982)
-
- def test_big_linenos(self):
- def func(count):
- namespace = {}
- func = "def foo():\n " + "".join(["\n "] * count + ["spam\n"])
- exec func in namespace
- return namespace['foo']
-
- # Test all small ranges
- for i in xrange(1, 300):
- expected = _BIG_LINENO_FORMAT % (i + 2)
- self.do_disassembly_test(func(i), expected)
-
- # Test some larger ranges too
- for i in xrange(300, 5000, 10):
- expected = _BIG_LINENO_FORMAT % (i + 2)
- self.do_disassembly_test(func(i), expected)
-
-def test_main():
- run_unittest(DisTests)
-
-
-if __name__ == "__main__":
- test_main()
diff --git a/lib-python/2.7/test/test_sets.py b/lib-python/modified-2.7/test/test_sets.py
copy from lib-python/2.7/test/test_sets.py
copy to lib-python/modified-2.7/test/test_sets.py
--- a/lib-python/2.7/test/test_sets.py
+++ b/lib-python/modified-2.7/test/test_sets.py
@@ -686,7 +686,9 @@
set_list = sorted(self.set)
self.assertEqual(len(dup_list), len(set_list))
for i, el in enumerate(dup_list):
- self.assertIs(el, set_list[i])
+ # Object identity is not guarnteed for immutable objects, so we
+ # can't use assertIs here.
+ self.assertEqual(el, set_list[i])
def test_deep_copy(self):
dup = copy.deepcopy(self.set)
diff --git a/lib-python/modified-2.7/test/test_weakref.py b/lib-python/modified-2.7/test/test_weakref.py
--- a/lib-python/modified-2.7/test/test_weakref.py
+++ b/lib-python/modified-2.7/test/test_weakref.py
@@ -993,13 +993,13 @@
self.assertTrue(len(weakdict) == 2)
k, v = weakdict.popitem()
self.assertTrue(len(weakdict) == 1)
- if k is key1:
+ if k == key1:
self.assertTrue(v is value1)
else:
self.assertTrue(v is value2)
k, v = weakdict.popitem()
self.assertTrue(len(weakdict) == 0)
- if k is key1:
+ if k == key1:
self.assertTrue(v is value1)
else:
self.assertTrue(v is value2)
diff --git a/lib_pypy/_ctypes/__init__.py b/lib_pypy/_ctypes/__init__.py
--- a/lib_pypy/_ctypes/__init__.py
+++ b/lib_pypy/_ctypes/__init__.py
@@ -18,7 +18,16 @@
if _os.name in ("nt", "ce"):
from _rawffi import FormatError
from _rawffi import check_HRESULT as _check_HRESULT
- CopyComPointer = None # XXX
+
+ def CopyComPointer(src, dst):
+ from ctypes import c_void_p, cast
+ if src:
+ hr = src[0][0].AddRef(src)
+ if hr & 0x80000000:
+ return hr
+ dst[0] = cast(src, c_void_p).value
+ return 0
+
LoadLibrary = dlopen
from _rawffi import FUNCFLAG_STDCALL, FUNCFLAG_CDECL, FUNCFLAG_PYTHONAPI
diff --git a/lib_pypy/_ctypes/basics.py b/lib_pypy/_ctypes/basics.py
--- a/lib_pypy/_ctypes/basics.py
+++ b/lib_pypy/_ctypes/basics.py
@@ -139,7 +139,10 @@
return buffer(self._buffer)
def _get_b_base(self):
- return self._base
+ try:
+ return self._base
+ except AttributeError:
+ return None
_b_base_ = property(_get_b_base)
_b_needsfree_ = False
@@ -218,5 +221,7 @@
'z' : _ffi.types.void_p,
'O' : _ffi.types.void_p,
'Z' : _ffi.types.void_p,
+ 'X' : _ffi.types.void_p,
+ 'v' : _ffi.types.sshort,
}
diff --git a/lib_pypy/_ctypes/function.py b/lib_pypy/_ctypes/function.py
--- a/lib_pypy/_ctypes/function.py
+++ b/lib_pypy/_ctypes/function.py
@@ -322,20 +322,18 @@
RuntimeWarning, stacklevel=2)
if self._com_index:
- assert False, 'TODO2'
from ctypes import cast, c_void_p, POINTER
if not args:
raise ValueError(
"native COM method call without 'this' parameter"
)
- thisarg = cast(args[0], POINTER(POINTER(c_void_p))).contents
- argtypes = [c_void_p] + list(argtypes)
- args = list(args)
- args[0] = args[0].value
+ thisarg = cast(args[0], POINTER(POINTER(c_void_p)))
+ newargs, argtypes, outargs = self._convert_args(argtypes, args[1:], kwargs)
+ newargs.insert(0, args[0].value)
+ argtypes.insert(0, c_void_p)
else:
thisarg = None
-
- newargs, argtypes, outargs = self._convert_args(argtypes, args, kwargs)
+ newargs, argtypes, outargs = self._convert_args(argtypes, args, kwargs)
funcptr = self._getfuncptr(argtypes, self._restype_, thisarg)
result = self._call_funcptr(funcptr, *newargs)
@@ -343,6 +341,11 @@
if not outargs:
return result
+
+ simple_cdata = type(c_void_p()).__bases__[0]
+ outargs = [x.value if type(x).__bases__[0] is simple_cdata else x
+ for x in outargs]
+
if len(outargs) == 1:
return outargs[0]
return tuple(outargs)
@@ -398,10 +401,10 @@
# extract the address from the object's virtual table
if not thisarg:
raise ValueError("COM method call without VTable")
- ptr = thisarg[self._com_index - 0x1000]
- argshapes = [arg._ffiargshape for arg in argtypes]
- resshape = restype._ffiargshape
- return _rawffi.FuncPtr(ptr, argshapes, resshape, self._flags_)
+ ptr = thisarg[0][self._com_index - 0x1000]
+ ffiargs = [argtype.get_ffi_argtype() for argtype in argtypes]
+ ffires = restype.get_ffi_argtype()
+ return _ffi.FuncPtr.fromaddr(ptr, '', ffiargs, ffires)
cdll = self.dll._handle
try:
@@ -468,11 +471,7 @@
newargtypes = []
total = len(args)
paramflags = self._paramflags
-
- if self._com_index:
- inargs_idx = 1
- else:
- inargs_idx = 0
+ inargs_idx = 0
if not paramflags and total < len(argtypes):
raise TypeError("not enough arguments")
@@ -587,13 +586,7 @@
retval = None
- if self._com_index:
- if resbuffer[0] & 0x80000000:
- raise get_com_error(resbuffer[0],
- self._com_iid, argsandobjs[0])
- else:
- retval = int(resbuffer[0])
- elif restype is not None:
+ if restype is not None:
checker = getattr(self.restype, '_check_retval_', None)
if checker:
val = restype(result)
@@ -601,7 +594,13 @@
# classes defining a new type, and their subclasses
if '_type_' in restype.__dict__:
val = val.value
- retval = checker(val)
+ # XXX Raise a COMError when restype is HRESULT and
+ # checker(val) fails. How to check for restype == HRESULT?
+ if self._com_index:
+ if result & 0x80000000:
+ raise get_com_error(result, None, None)
+ else:
+ retval = checker(val)
elif not isinstance(restype, _CDataMeta):
retval = restype(result)
else:
diff --git a/lib_pypy/_ctypes/primitive.py b/lib_pypy/_ctypes/primitive.py
--- a/lib_pypy/_ctypes/primitive.py
+++ b/lib_pypy/_ctypes/primitive.py
@@ -216,10 +216,15 @@
result.value = property(_getvalue, _setvalue)
elif tp == 'X':
- from ctypes import windll
- SysAllocStringLen = windll.oleaut32.SysAllocStringLen
- SysStringLen = windll.oleaut32.SysStringLen
- SysFreeString = windll.oleaut32.SysFreeString
+ from ctypes import WinDLL
+ # Use WinDLL("oleaut32") instead of windll.oleaut32
+ # because the latter is a shared (cached) object; and
+ # other code may set their own restypes. We need out own
+ # restype here.
+ oleaut32 = WinDLL("oleaut32")
+ SysAllocStringLen = oleaut32.SysAllocStringLen
+ SysStringLen = oleaut32.SysStringLen
+ SysFreeString = oleaut32.SysFreeString
def _getvalue(self):
addr = self._buffer[0]
if addr == 0:
diff --git a/lib_pypy/binascii.py b/lib_pypy/binascii.py
--- a/lib_pypy/binascii.py
+++ b/lib_pypy/binascii.py
@@ -659,7 +659,7 @@
crc = crc_32_tab[(crc ^ long(ord(c))) & 0xffL] ^ (crc >> 8)
#/* Note: (crc >> 8) MUST zero fill on left
- result = crc ^ 0xffffffffL
+ result = crc ^ 0xffffffffL
if result > 2**31:
result = ((result + 2**31) % 2**32) - 2**31
diff --git a/lib_pypy/pwd.py b/lib_pypy/pwd.py
--- a/lib_pypy/pwd.py
+++ b/lib_pypy/pwd.py
@@ -16,6 +16,7 @@
from ctypes_support import standard_c_lib as libc
from ctypes import Structure, POINTER, c_int, c_char_p, c_long
+from _structseq import structseqtype, structseqfield
try: from __pypy__ import builtinify
except ImportError: builtinify = lambda f: f
@@ -68,7 +69,7 @@
yield self.pw_dir
yield self.pw_shell
-class struct_passwd(tuple):
+class struct_passwd:
"""
pwd.struct_passwd: Results from getpw*() routines.
@@ -76,15 +77,15 @@
(pw_name,pw_passwd,pw_uid,pw_gid,pw_gecos,pw_dir,pw_shell)
or via the object attributes as named in the above tuple.
"""
- def __init__(self, passwd):
- self.pw_name = passwd.pw_name
- self.pw_passwd = passwd.pw_passwd
- self.pw_uid = passwd.pw_uid
- self.pw_gid = passwd.pw_gid
- self.pw_gecos = passwd.pw_gecos
- self.pw_dir = passwd.pw_dir
- self.pw_shell = passwd.pw_shell
- tuple.__init__(self, passwd)
+ __metaclass__ = structseqtype
+ name = "pwd.struct_passwd"
+ pw_name = structseqfield(0)
+ pw_passwd = structseqfield(1)
+ pw_uid = structseqfield(2)
+ pw_gid = structseqfield(3)
+ pw_gecos = structseqfield(4)
+ pw_dir = structseqfield(5)
+ pw_shell = structseqfield(6)
passwd_p = POINTER(passwd)
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/config/pypyoption.py b/pypy/config/pypyoption.py
--- a/pypy/config/pypyoption.py
+++ b/pypy/config/pypyoption.py
@@ -129,9 +129,6 @@
cmdline='--objspace -o'),
OptionDescription("opcodes", "opcodes to enable in the interpreter", [
- BoolOption("CALL_LIKELY_BUILTIN", "emit a special bytecode for likely calls to builtin functions",
- default=False,
- requires=[("translation.stackless", False)]),
BoolOption("CALL_METHOD", "emit a special bytecode for expr.name()",
default=False),
]),
@@ -266,13 +263,7 @@
BoolOption("withcelldict",
"use dictionaries that are optimized for being used as module dicts",
default=False,
- requires=[("objspace.opcodes.CALL_LIKELY_BUILTIN", False),
- ("objspace.honor__builtins__", False)]),
-
- BoolOption("withdictmeasurement",
- "create huge files with masses of information "
- "about dictionaries",
- default=False),
+ requires=[("objspace.honor__builtins__", False)]),
BoolOption("withmapdict",
"make instances really small but slow without the JIT",
@@ -355,8 +346,6 @@
backend = config.translation.backend
# all the good optimizations for PyPy should be listed here
- if level in ['2', '3']:
- config.objspace.opcodes.suggest(CALL_LIKELY_BUILTIN=True)
if level in ['2', '3', 'jit']:
config.objspace.opcodes.suggest(CALL_METHOD=True)
config.objspace.std.suggest(withrangelist=True)
diff --git a/pypy/doc/config/objspace.opcodes.CALL_LIKELY_BUILTIN.txt b/pypy/doc/config/objspace.opcodes.CALL_LIKELY_BUILTIN.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.opcodes.CALL_LIKELY_BUILTIN.txt
+++ /dev/null
@@ -1,12 +0,0 @@
-Introduce a new opcode called ``CALL_LIKELY_BUILTIN``. It is used when something
-is called, that looks like a builtin function (but could in reality be shadowed
-by a name in the module globals). For all module globals dictionaries it is
-then tracked which builtin name is shadowed in this module. If the
-``CALL_LIKELY_BUILTIN`` opcode is executed, it is checked whether the builtin is
-shadowed. If not, the corresponding builtin is called. Otherwise the object that
-is shadowing it is called instead. If no shadowing is happening, this saves two
-dictionary lookups on calls to builtins.
-
-For more information, see the section in `Standard Interpreter Optimizations`_.
-
-.. _`Standard Interpreter Optimizations`: ../interpreter-optimizations.html#call-likely-builtin
diff --git a/pypy/doc/config/objspace.std.withdictmeasurement.txt b/pypy/doc/config/objspace.std.withdictmeasurement.txt
deleted file mode 100644
--- a/pypy/doc/config/objspace.std.withdictmeasurement.txt
+++ /dev/null
@@ -1,3 +0,0 @@
-Internal option.
-
-.. internal
diff --git a/pypy/doc/cpython_differences.rst b/pypy/doc/cpython_differences.rst
--- a/pypy/doc/cpython_differences.rst
+++ b/pypy/doc/cpython_differences.rst
@@ -248,5 +248,7 @@
never a dictionary as it sometimes is in CPython. Assigning to
``__builtins__`` has no effect.
+* object identity of immutable keys in dictionaries is not necessarily preserved.
+ Never compare immutable objects with ``is``.
+
.. include:: _ref.txt
-
diff --git a/pypy/doc/getting-started.rst b/pypy/doc/getting-started.rst
--- a/pypy/doc/getting-started.rst
+++ b/pypy/doc/getting-started.rst
@@ -51,7 +51,7 @@
---------------
PyPy is ready to be executed as soon as you unpack the tarball or the zip
-file, with no need install it in any specific location::
+file, with no need to install it in any specific location::
$ tar xf pypy-1.5-linux.tar.bz2
diff --git a/pypy/doc/index.rst b/pypy/doc/index.rst
--- a/pypy/doc/index.rst
+++ b/pypy/doc/index.rst
@@ -11,6 +11,10 @@
Getting into PyPy ...
=============================================
+* `Getting started`_: how to install and run the PyPy Python interpreter
+
+* `FAQ`_: some frequently asked questions.
+
* `Release 1.5`_: the latest official release
* `PyPy Blog`_: news and status info about PyPy
@@ -26,13 +30,6 @@
Documentation for the PyPy Python Interpreter
===============================================
-`getting started`_ provides hands-on instructions
-including a two-liner to run the PyPy Python interpreter
-on your system, examples on advanced features and
-entry points for using the `RPython toolchain`_.
-
-`FAQ`_ contains some frequently asked questions.
-
New features of PyPy's Python Interpreter and
Translation Framework:
diff --git a/pypy/doc/interpreter-optimizations.rst b/pypy/doc/interpreter-optimizations.rst
--- a/pypy/doc/interpreter-optimizations.rst
+++ b/pypy/doc/interpreter-optimizations.rst
@@ -157,32 +157,6 @@
A more advanced version of sharing dicts, called *map dicts,* is available
with the :config:`objspace.std.withmapdict` option.
-Builtin-Shadowing
-+++++++++++++++++
-
-Usually the calling of builtins in Python requires two dictionary lookups: first
-to see whether the current global dictionary contains an object with the same
-name, then a lookup in the ``__builtin__`` dictionary. This is somehow
-circumvented by storing an often used builtin into a local variable to get
-the fast local lookup (which is a rather strange and ugly hack).
-
-The same problem is solved in a different way by "wary" dictionaries. They are
-another dictionary representation used together with multidicts. This
-representation is used only for module dictionaries. The representation checks on
-every setitem whether the key that is used is the name of a builtin. If this is
-the case, the dictionary is marked as shadowing that particular builtin.
-
-To identify calls to builtins easily, a new bytecode (``CALL_LIKELY_BUILTIN``)
-is introduced. Whenever it is executed, the globals dictionary is checked
-to see whether it masks the builtin (which is possible without a dictionary
-lookup). Then the ``__builtin__`` dict is checked in the same way,
-to see whether somebody replaced the real builtin with something else. In the
-common case, the program didn't do any of these; the proper builtin can then
-be called without using any dictionary lookup at all.
-
-You can enable this feature with the
-:config:`objspace.opcodes.CALL_LIKELY_BUILTIN` option.
-
List Optimizations
------------------
@@ -289,34 +263,6 @@
You can enable this feature with the :config:`objspace.opcodes.CALL_METHOD`
option.
-.. _`call likely builtin`:
-
-CALL_LIKELY_BUILTIN
-+++++++++++++++++++
-
-A often heard "tip" for speeding up Python programs is to give an often used
-builtin a local name, since local lookups are faster than lookups of builtins,
-which involve doing two dictionary lookups: one in the globals dictionary and
-one in the the builtins dictionary. PyPy approaches this problem at the
-implementation level, with the introduction of the new ``CALL_LIKELY_BUILTIN``
-bytecode. This bytecode is produced by the compiler for a call whose target is
-the name of a builtin. Since such a syntactic construct is very often actually
-invoking the expected builtin at run-time, this information can be used to make
-the call to the builtin directly, without going through any dictionary lookup.
-
-However, it can occur that the name is shadowed by a global name from the
-current module. To catch this case, a special dictionary implementation for
-multidicts is introduced, which is used for the dictionaries of modules. This
-implementation keeps track which builtin name is shadowed by it. The
-``CALL_LIKELY_BUILTIN`` bytecode asks the dictionary whether it is shadowing the
-builtin that is about to be called and asks the dictionary of ``__builtin__``
-whether the original builtin was changed. These two checks are cheaper than
-full lookups. In the common case, neither of these cases is true, so the
-builtin can be directly invoked.
-
-You can enable this feature with the
-:config:`objspace.opcodes.CALL_LIKELY_BUILTIN` option.
-
.. more here?
Overall Effects
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/astcompiler/assemble.py b/pypy/interpreter/astcompiler/assemble.py
--- a/pypy/interpreter/astcompiler/assemble.py
+++ b/pypy/interpreter/astcompiler/assemble.py
@@ -655,9 +655,6 @@
def _compute_CALL_FUNCTION_VAR_KW(arg):
return -_num_args(arg) - 2
-def _compute_CALL_LIKELY_BUILTIN(arg):
- return -(arg & 0xFF) + 1
-
def _compute_CALL_METHOD(arg):
return -_num_args(arg) - 1
diff --git a/pypy/interpreter/astcompiler/codegen.py b/pypy/interpreter/astcompiler/codegen.py
--- a/pypy/interpreter/astcompiler/codegen.py
+++ b/pypy/interpreter/astcompiler/codegen.py
@@ -12,7 +12,6 @@
from pypy.interpreter.pyparser.error import SyntaxError
from pypy.tool import stdlib_opcode as ops
from pypy.interpreter.error import OperationError
-from pypy.module.__builtin__.__init__ import BUILTIN_TO_INDEX
def compile_ast(space, module, info):
@@ -942,8 +941,7 @@
def visit_Call(self, call):
self.update_position(call.lineno)
- if self._optimize_builtin_call(call) or \
- self._optimize_method_call(call):
+ if self._optimize_method_call(call):
return
call.func.walkabout(self)
arg = 0
@@ -977,28 +975,6 @@
def _call_has_simple_args(self, call):
return self._call_has_no_star_args(call) and not call.keywords
- def _optimize_builtin_call(self, call):
- if not self.space.config.objspace.opcodes.CALL_LIKELY_BUILTIN or \
- not self._call_has_simple_args(call) or \
- not isinstance(call.func, ast.Name):
- return False
- func_name = call.func
- assert isinstance(func_name, ast.Name)
- name_scope = self.scope.lookup(func_name.id)
- if name_scope == symtable.SCOPE_GLOBAL_IMPLICIT or \
- name_scope == symtable.SCOPE_UNKNOWN:
- builtin_index = BUILTIN_TO_INDEX.get(func_name.id, -1)
- if builtin_index != -1:
- if call.args:
- args_count = len(call.args)
- self.visit_sequence(call.args)
- else:
- args_count = 0
- arg = builtin_index << 8 | args_count
- self.emit_op_arg(ops.CALL_LIKELY_BUILTIN, arg)
- return True
- return False
-
def _optimize_method_call(self, call):
if not self.space.config.objspace.opcodes.CALL_METHOD or \
not self._call_has_no_star_args(call) or \
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -237,7 +237,7 @@
class ObjSpace(object):
"""Base class for the interpreter-level implementations of object spaces.
- http://codespeak.net/pypy/dist/pypy/doc/objspace.html"""
+ http://pypy.readthedocs.org/en/latest/objspace.html"""
full_exceptions = True # full support for exceptions (normalization & more)
@@ -311,9 +311,6 @@
mod = self.interpclass_w(w_mod)
if isinstance(mod, Module) and mod.startup_called:
mod.shutdown(self)
- if self.config.objspace.std.withdictmeasurement:
- from pypy.objspace.std.dictmultiobject import report
- report()
if self.config.objspace.logbytecodes:
self.reportbytecodecounts()
if self.config.objspace.std.logspaceoptypes:
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
@@ -465,19 +465,23 @@
space.abstract_isinstance_w(w_firstarg, self.w_class)):
pass # ok
else:
- myname = self.getname(space,"")
- clsdescr = self.w_class.getname(space,"")
+ myname = self.getname(space, "")
+ clsdescr = self.w_class.getname(space, "")
if clsdescr:
- clsdescr+=" "
+ clsdescr += " instance"
+ else:
+ clsdescr = "instance"
if w_firstarg is None:
instdescr = "nothing"
else:
- instname = space.abstract_getclass(w_firstarg).getname(space,"")
+ instname = space.abstract_getclass(w_firstarg).getname(space,
+ "")
if instname:
- instname += " "
- instdescr = "%sinstance" %instname
- msg = ("unbound method %s() must be called with %s"
- "instance as first argument (got %s instead)")
+ instdescr = instname + " instance"
+ else:
+ instdescr = "instance"
+ msg = ("unbound method %s() must be called with %s "
+ "as first argument (got %s instead)")
raise operationerrfmt(space.w_TypeError, msg,
myname, clsdescr, instdescr)
return space.call_args(self.w_function, args)
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/pyopcode.py b/pypy/interpreter/pyopcode.py
--- a/pypy/interpreter/pyopcode.py
+++ b/pypy/interpreter/pyopcode.py
@@ -1060,18 +1060,6 @@
def SET_LINENO(self, lineno, next_instr):
pass
- def CALL_LIKELY_BUILTIN(self, oparg, next_instr):
- # overridden by faster version in the standard object space.
- from pypy.module.__builtin__ import OPTIMIZED_BUILTINS
- varname = OPTIMIZED_BUILTINS[oparg >> 8]
- w_function = self._load_global(varname)
- nargs = oparg&0xFF
- try:
- w_result = self.space.call_valuestack(w_function, nargs, self)
- finally:
- self.dropvalues(nargs)
- self.pushvalue(w_result)
-
# overridden by faster version in the standard object space.
LOOKUP_METHOD = LOAD_ATTR
CALL_METHOD = CALL_FUNCTION
diff --git a/pypy/interpreter/test/test_executioncontext.py b/pypy/interpreter/test/test_executioncontext.py
--- a/pypy/interpreter/test/test_executioncontext.py
+++ b/pypy/interpreter/test/test_executioncontext.py
@@ -106,7 +106,7 @@
if isinstance(seen[0], Method):
found = 'method %s of %s' % (
seen[0].w_function.name,
- seen[0].w_class.getname(space, '?'))
+ seen[0].w_class.getname(space))
else:
assert isinstance(seen[0], Function)
found = 'builtin %s' % seen[0].name
@@ -232,31 +232,6 @@
assert [i[0] for i in events] == ['c_call', 'c_return', 'return', 'c_call']
assert events[0][1] == events[1][1]
- def test_tracing_range_builtinshortcut(self):
- opts = {"objspace.opcodes.CALL_LIKELY_BUILTIN": True}
- space = gettestobjspace(**opts)
- source = """def f(profile):
- import sys
- sys.setprofile(profile)
- range(10)
- sys.setprofile(None)
- """
- w_events = space.appexec([space.wrap(source)], """(source):
- import sys
- l = []
- def profile(frame, event, arg):
- l.append((event, arg))
- d = {}
- exec source in d
- f = d['f']
- f(profile)
- import dis
- print dis.dis(f)
- return l
- """)
- events = space.unwrap(w_events)
- assert [i[0] for i in events] == ['c_call', 'c_return', 'c_call']
-
def test_profile_and_exception(self):
space = self.space
w_res = space.appexec([], """():
@@ -280,9 +255,6 @@
""")
-class TestExecutionContextWithCallLikelyBuiltin(TestExecutionContext):
- keywords = {'objspace.opcodes.CALL_LIKELY_BUILTIN': True}
-
class TestExecutionContextWithCallMethod(TestExecutionContext):
keywords = {'objspace.opcodes.CALL_METHOD': True}
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:
@@ -210,19 +210,20 @@
def m(self):
"aaa"
m.x = 3
+ class B(A):
+ pass
- bm = A().m
+ bm = B().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.im_class is B
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
+ # note: 'l.__add__.__objclass__' is not defined in pypy
+ # because it's a regular method, and .__objclass__
+ # differs from .im_class in case the method is
+ # defined in some parent class of l's actual class
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/assembler.py b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -415,12 +415,13 @@
fullsize = self.mc.get_relative_pos()
#
rawstart = self.materialize_loop(looptoken)
- debug_start("jit-backend")
- debug_print("Loop #%d (%s) has address %x to %x" % (
+ debug_start("jit-backend-addr")
+ debug_print("Loop %d (%s) has address %x to %x (bootstrap %x)" % (
looptoken.number, loopname,
rawstart + self.looppos,
- rawstart + directbootstrappos))
- debug_stop("jit-backend")
+ rawstart + directbootstrappos,
+ rawstart))
+ debug_stop("jit-backend-addr")
self._patch_stackadjust(rawstart + stackadjustpos,
frame_depth + param_depth)
self.patch_pending_failure_recoveries(rawstart)
@@ -479,9 +480,10 @@
fullsize = self.mc.get_relative_pos()
#
rawstart = self.materialize_loop(original_loop_token)
-
- debug_print("Bridge out of guard %d has address %x to %x" %
+ debug_start("jit-backend-addr")
+ debug_print("Bridge out of Guard %d has address %x to %x" %
(descr_number, rawstart, rawstart + codeendpos))
+ debug_stop("jit-backend-addr")
self._patch_stackadjust(rawstart + stackadjustpos,
frame_depth + param_depth)
self.patch_pending_failure_recoveries(rawstart)
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
@@ -870,7 +870,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
@@ -1351,13 +1351,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)
@@ -1403,7 +1403,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
@@ -123,7 +123,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/history.py b/pypy/jit/metainterp/history.py
--- a/pypy/jit/metainterp/history.py
+++ b/pypy/jit/metainterp/history.py
@@ -765,6 +765,7 @@
"""
short_preamble = None
failed_states = None
+ retraced_count = 0
terminating = False # see TerminatingLoopToken in compile.py
outermost_jitdriver_sd = None
# and more data specified by the backend when the loop is compiled
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
@@ -3,7 +3,7 @@
from pypy.jit.metainterp.optimizeopt.intbounds import OptIntBounds
from pypy.jit.metainterp.optimizeopt.virtualize import OptVirtualize
from pypy.jit.metainterp.optimizeopt.heap import OptHeap
-from pypy.jit.metainterp.optimizeopt.string import OptString
+from pypy.jit.metainterp.optimizeopt.vstring 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
@@ -21,15 +21,14 @@
unroll_all_opts = unrolling_iterable(ALL_OPTS)
ALL_OPTS_DICT = dict.fromkeys([name for name, _ in ALL_OPTS])
-
+ALL_OPTS_LIST = [name for name, _ in ALL_OPTS]
ALL_OPTS_NAMES = ':'.join([name for name, _ in ALL_OPTS])
-PARAMETERS['enable_opts'] = ALL_OPTS_NAMES
def build_opt_chain(metainterp_sd, enable_opts,
inline_short_preamble=True, retraced=False):
config = metainterp_sd.config
optimizations = []
- unroll = 'unroll' in enable_opts
+ unroll = 'unroll' in enable_opts # 'enable_opts' is normally a dict
for name, opt in unroll_all_opts:
if name in enable_opts:
if opt is not None:
diff --git a/pypy/jit/metainterp/optimizeopt/fficall.py b/pypy/jit/metainterp/optimizeopt/fficall.py
--- a/pypy/jit/metainterp/optimizeopt/fficall.py
+++ b/pypy/jit/metainterp/optimizeopt/fficall.py
@@ -4,7 +4,7 @@
from pypy.rlib.debug import debug_start, debug_stop, debug_print, have_debug_prints
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.metainterp.resoperation import rop, ResOperation
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
from pypy.jit.backend.llsupport.ffisupport import UnsupportedKind
@@ -203,13 +203,7 @@
def propagate_forward(self, op):
if self.logops is not None:
debug_print(self.logops.repr_of_resop(op))
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
+ dispatch_opt(self, op)
def _get_oopspec(self, op):
effectinfo = op.getdescr().get_extra_info()
@@ -220,4 +214,5 @@
def _get_funcval(self, op):
return self.getvalue(op.getarg(1))
-optimize_ops = _findall(OptFfiCall, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptFfiCall, 'optimize_',
+ default=OptFfiCall.emit_operation)
diff --git a/pypy/jit/metainterp/optimizeopt/heap.py b/pypy/jit/metainterp/optimizeopt/heap.py
--- a/pypy/jit/metainterp/optimizeopt/heap.py
+++ b/pypy/jit/metainterp/optimizeopt/heap.py
@@ -1,5 +1,5 @@
import os
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.rlib.objectmodel import we_are_translated
from pypy.jit.metainterp.jitexc import JitException
@@ -431,13 +431,7 @@
self._seen_guard_not_invalidated = True
self.emit_operation(op)
- def propagate_forward(self, op):
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
-optimize_ops = _findall(OptHeap, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptHeap, 'optimize_',
+ default=OptHeap.emit_operation)
+OptHeap.propagate_forward = dispatch_opt
diff --git a/pypy/jit/metainterp/optimizeopt/intbounds.py b/pypy/jit/metainterp/optimizeopt/intbounds.py
--- a/pypy/jit/metainterp/optimizeopt/intbounds.py
+++ b/pypy/jit/metainterp/optimizeopt/intbounds.py
@@ -1,5 +1,5 @@
from pypy.jit.metainterp.optimizeopt.optimizer import Optimization, CONST_1, CONST_0
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.optimizeopt.intutils import (IntBound, IntUnbounded,
IntLowerBound, IntUpperBound)
from pypy.jit.metainterp.history import Const, ConstInt
@@ -34,14 +34,11 @@
op = self.posponedop
self.posponedop = None
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- assert not op.is_ovf()
- self.emit_operation(op)
+ dispatch_opt(self, op)
+
+ def opt_default(self, op):
+ assert not op.is_ovf()
+ self.emit_operation(op)
def propagate_bounds_backward(self, box):
@@ -57,11 +54,7 @@
op = self.optimizer.producer[box]
except KeyError:
return
- opnum = op.getopnum()
- for value, func in propagate_bounds_ops:
- if opnum == value:
- func(self, op)
- break
+ dispatch_bounds_ops(self, op)
def optimize_GUARD_TRUE(self, op):
self.emit_operation(op)
@@ -382,6 +375,18 @@
v1.intbound.make_gt(IntBound(0, 0))
self.propagate_bounds_backward(op.getarg(0))
+ def propagate_bounds_INT_IS_ZERO(self, op):
+ r = self.getvalue(op.result)
+ if r.is_constant():
+ if r.box.same_constant(CONST_1):
+ v1 = self.getvalue(op.getarg(0))
+ # Clever hack, we can't use self.make_constant_int yet because
+ # the args aren't in the values dictionary yet so it runs into
+ # an assert, this is a clever way of expressing the same thing.
+ v1.intbound.make_ge(IntBound(0, 0))
+ v1.intbound.make_lt(IntBound(1, 1))
+ self.propagate_bounds_backward(op.getarg(0))
+
def propagate_bounds_INT_ADD(self, op):
v1 = self.getvalue(op.getarg(0))
v2 = self.getvalue(op.getarg(1))
@@ -428,5 +433,6 @@
propagate_bounds_INT_MUL_OVF = propagate_bounds_INT_MUL
-optimize_ops = _findall(OptIntBounds, 'optimize_')
-propagate_bounds_ops = _findall(OptIntBounds, 'propagate_bounds_')
+dispatch_opt = make_dispatcher_method(OptIntBounds, 'optimize_',
+ default=OptIntBounds.opt_default)
+dispatch_bounds_ops = make_dispatcher_method(OptIntBounds, 'propagate_bounds_')
diff --git a/pypy/jit/metainterp/optimizeopt/optimizer.py b/pypy/jit/metainterp/optimizeopt/optimizer.py
--- a/pypy/jit/metainterp/optimizeopt/optimizer.py
+++ b/pypy/jit/metainterp/optimizeopt/optimizer.py
@@ -4,7 +4,7 @@
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.metainterp import jitprof
from pypy.jit.metainterp.executor import execute_nonspec
-from pypy.jit.metainterp.optimizeopt.util import _findall, sort_descrs
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method, sort_descrs
from pypy.jit.metainterp.optimizeopt.util import descrlist_dict, args_dict
from pypy.jit.metainterp.optimize import InvalidLoop
from pypy.jit.metainterp import resume, compile
@@ -434,14 +434,7 @@
def propagate_forward(self, op):
self.producer[op.result] = op
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.optimize_default(op)
- #print '\n'.join([str(o) for o in self.newoperations]) + '\n---\n'
+ dispatch_opt(self, op)
def test_emittable(self, op):
return True
@@ -569,7 +562,8 @@
def optimize_DEBUG_MERGE_POINT(self, op):
self.emit_operation(op)
-optimize_ops = _findall(Optimizer, 'optimize_')
+dispatch_opt = make_dispatcher_method(Optimizer, 'optimize_',
+ default=Optimizer.optimize_default)
diff --git a/pypy/jit/metainterp/optimizeopt/rewrite.py b/pypy/jit/metainterp/optimizeopt/rewrite.py
--- a/pypy/jit/metainterp/optimizeopt/rewrite.py
+++ b/pypy/jit/metainterp/optimizeopt/rewrite.py
@@ -1,7 +1,7 @@
from pypy.jit.metainterp.optimizeopt.optimizer import *
from pypy.jit.metainterp.resoperation import opboolinvers, opboolreflex
from pypy.jit.metainterp.history import ConstInt
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import _findall, make_dispatcher_method
from pypy.jit.metainterp.resoperation import rop, ResOperation
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.metainterp.optimizeopt.intutils import IntBound
@@ -21,18 +21,13 @@
if self.find_rewritable_bool(op, args):
return
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
+ dispatch_opt(self, op)
def test_emittable(self, op):
opnum = op.getopnum()
- for value, func in optimize_guards:
+ for value, cls, func in optimize_guards:
if opnum == value:
+ assert isinstance(op, cls)
try:
func(self, op, dryrun=True)
return self.is_emittable(op)
@@ -477,5 +472,6 @@
self.emit_operation(op)
-optimize_ops = _findall(OptRewrite, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptRewrite, 'optimize_',
+ default=OptRewrite.emit_operation)
optimize_guards = _findall(OptRewrite, 'optimize_', 'GUARD')
diff --git a/pypy/jit/metainterp/optimizeopt/simplify.py b/pypy/jit/metainterp/optimizeopt/simplify.py
--- a/pypy/jit/metainterp/optimizeopt/simplify.py
+++ b/pypy/jit/metainterp/optimizeopt/simplify.py
@@ -1,7 +1,7 @@
from pypy.jit.metainterp.resoperation import ResOperation, rop
from pypy.jit.metainterp.optimizeopt.optimizer import Optimization
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
class OptSimplify(Optimization):
def optimize_CALL_PURE(self, op):
@@ -25,13 +25,7 @@
# but it's a bit hard to implement robustly if heap.py is also run
pass
- def propagate_forward(self, op):
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
-optimize_ops = _findall(OptSimplify, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptSimplify, 'optimize_',
+ default=OptSimplify.emit_operation)
+OptSimplify.propagate_forward = dispatch_opt
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -439,6 +439,23 @@
"""
self.optimize_loop(ops, expected)
+ def test_int_is_zero_int_is_true(self):
+ ops = """
+ [i0]
+ i1 = int_is_zero(i0)
+ guard_true(i1) []
+ i2 = int_is_true(i0)
+ guard_false(i2) []
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ i1 = int_is_zero(i0)
+ guard_true(i1) []
+ jump(0)
+ """
+ self.optimize_loop(ops, expected)
+
def test_ooisnull_oononnull_2(self):
ops = """
[p0]
@@ -4123,7 +4140,6 @@
# ----------
def optimize_strunicode_loop_extradescrs(self, ops, optops):
- from pypy.jit.metainterp.optimizeopt import string
class FakeCallInfoCollection:
def callinfo_for_oopspec(self, oopspecindex):
calldescrtype = type(LLtypeMixin.strequaldescr)
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -5373,7 +5373,6 @@
# ----------
def optimize_strunicode_loop_extradescrs(self, ops, optops, preamble=None):
- from pypy.jit.metainterp.optimizeopt import string
class FakeCallInfoCollection:
def callinfo_for_oopspec(self, oopspecindex):
calldescrtype = type(LLtypeMixin.strequaldescr)
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
@@ -676,24 +676,28 @@
jumpop = self.optimizer.newoperations.pop()
assert jumpop.getopnum() == rop.JUMP
for guard in extra_guards:
- descr = sh.start_resumedescr.clone_if_mutable()
- self.inliner.inline_descr_inplace(descr)
- guard.setdescr(descr)
+ d = sh.start_resumedescr.clone_if_mutable()
+ self.inliner.inline_descr_inplace(d)
+ guard.setdescr(d)
self.emit_operation(guard)
self.optimizer.newoperations.append(jumpop)
return
- retraced_count = len(short)
- if descr.failed_states:
- retraced_count += len(descr.failed_states)
+ retraced_count = descr.retraced_count
+ descr.retraced_count += 1
limit = self.optimizer.metainterp_sd.warmrunnerdesc.memory_manager.retrace_limit
if not self.retraced and retraced_count<limit:
if not descr.failed_states:
+ debug_print("Retracing (%d of %d)" % (retraced_count,
+ limit))
raise RetraceLoop
for failed in descr.failed_states:
if failed.generalization_of(virtual_state):
# Retracing once more will most likely fail again
break
else:
+ debug_print("Retracing (%d of %d)" % (retraced_count,
+ limit))
+
raise RetraceLoop
else:
if not descr.failed_states:
diff --git a/pypy/jit/metainterp/optimizeopt/util.py b/pypy/jit/metainterp/optimizeopt/util.py
--- a/pypy/jit/metainterp/optimizeopt/util.py
+++ b/pypy/jit/metainterp/optimizeopt/util.py
@@ -20,9 +20,25 @@
if op_prefix and not name.startswith(op_prefix):
continue
if hasattr(Class, name_prefix + name):
- result.append((value, getattr(Class, name_prefix + name)))
+ opclass = resoperation.opclasses[getattr(rop, name)]
+ print value, name, opclass
+ result.append((value, opclass, getattr(Class, name_prefix + name)))
return unrolling_iterable(result)
+def make_dispatcher_method(Class, name_prefix, op_prefix=None, default=None):
+ ops = _findall(Class, name_prefix, op_prefix)
+ def dispatch(self, op, *args):
+ opnum = op.getopnum()
+ for value, cls, func in ops:
+ if opnum == value:
+ assert isinstance(op, cls)
+ return func(self, op, *args)
+ if default:
+ return default(self, op, *args)
+ dispatch.func_name = "dispatch_" + name_prefix
+ return dispatch
+
+
def partition(array, left, right):
last_item = array[right]
pivot = last_item.sort_key()
diff --git a/pypy/jit/metainterp/optimizeopt/virtualize.py b/pypy/jit/metainterp/optimizeopt/virtualize.py
--- a/pypy/jit/metainterp/optimizeopt/virtualize.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualize.py
@@ -1,7 +1,7 @@
from pypy.jit.metainterp.history import Const, ConstInt, BoxInt
from pypy.jit.metainterp.resoperation import rop, ResOperation
-from pypy.jit.metainterp.optimizeopt.util import _findall, sort_descrs
-from pypy.jit.metainterp.optimizeopt.util import descrlist_dict
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
+from pypy.jit.metainterp.optimizeopt.util import descrlist_dict, sort_descrs
from pypy.rlib.objectmodel import we_are_translated
from pypy.jit.metainterp.optimizeopt import optimizer
from pypy.jit.metainterp.executor import execute
@@ -456,13 +456,8 @@
###self.heap_op_optimizer.optimize_SETARRAYITEM_GC(op, value, fieldvalue)
self.emit_operation(op)
- def propagate_forward(self, op):
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
-optimize_ops = _findall(OptVirtualize, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptVirtualize, 'optimize_',
+ default=OptVirtualize.emit_operation)
+
+OptVirtualize.propagate_forward = dispatch_opt
diff --git a/pypy/jit/metainterp/optimizeopt/string.py b/pypy/jit/metainterp/optimizeopt/vstring.py
rename from pypy/jit/metainterp/optimizeopt/string.py
rename to pypy/jit/metainterp/optimizeopt/vstring.py
--- a/pypy/jit/metainterp/optimizeopt/string.py
+++ b/pypy/jit/metainterp/optimizeopt/vstring.py
@@ -8,7 +8,7 @@
from pypy.jit.metainterp.optimizeopt import optimizer, virtualize
from pypy.jit.metainterp.optimizeopt.optimizer import CONST_0, CONST_1
from pypy.jit.metainterp.optimizeopt.optimizer import llhelper
-from pypy.jit.metainterp.optimizeopt.util import _findall
+from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.codewriter.effectinfo import EffectInfo
from pypy.jit.codewriter import heaptracker
from pypy.rlib.unroll import unrolling_iterable
@@ -649,16 +649,11 @@
self.emit_operation(op)
return
- opnum = op.getopnum()
- for value, func in optimize_ops:
- if opnum == value:
- func(self, op)
- break
- else:
- self.emit_operation(op)
+ dispatch_opt(self, op)
-optimize_ops = _findall(OptString, 'optimize_')
+dispatch_opt = make_dispatcher_method(OptString, 'optimize_',
+ default=OptString.emit_operation)
def _findall_call_oopspec():
prefix = 'opt_call_stroruni_'
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
@@ -311,26 +311,27 @@
self.opimpl_goto_if_not(condbox, target)
''' % (_opimpl, _opimpl.upper())).compile()
+
+ def _establish_nullity(self, box, orgpc):
+ value = box.nonnull()
+ if value:
+ if box not in self.metainterp.known_class_boxes:
+ self.generate_guard(rop.GUARD_NONNULL, box, resumepc=orgpc)
+ else:
+ if not isinstance(box, Const):
+ self.generate_guard(rop.GUARD_ISNULL, box, resumepc=orgpc)
+ promoted_box = box.constbox()
+ self.metainterp.replace_box(box, promoted_box)
+ return value
+
@arguments("orgpc", "box", "label")
def opimpl_goto_if_not_ptr_nonzero(self, orgpc, box, target):
- value = box.nonnull()
- if value:
- opnum = rop.GUARD_NONNULL
- else:
- opnum = rop.GUARD_ISNULL
- self.generate_guard(opnum, box, resumepc=orgpc)
- if not value:
+ if not self._establish_nullity(box, orgpc):
self.pc = target
@arguments("orgpc", "box", "label")
def opimpl_goto_if_not_ptr_iszero(self, orgpc, box, target):
- value = box.nonnull()
- if value:
- opnum = rop.GUARD_NONNULL
- else:
- opnum = rop.GUARD_ISNULL
- self.generate_guard(opnum, box, resumepc=orgpc)
- if value:
+ if self._establish_nullity(box, orgpc):
self.pc = target
@arguments("box", "box", "box")
@@ -365,7 +366,9 @@
def opimpl_new_with_vtable(self, sizedescr):
cpu = self.metainterp.cpu
cls = heaptracker.descr2vtable(cpu, sizedescr)
- return self.execute(rop.NEW_WITH_VTABLE, ConstInt(cls))
+ resbox = self.execute(rop.NEW_WITH_VTABLE, ConstInt(cls))
+ self.metainterp.known_class_boxes[resbox] = None
+ return resbox
## @FixME #arguments("box")
## def opimpl_runtimenew(self, classbox):
@@ -863,7 +866,9 @@
@arguments("orgpc", "box")
def opimpl_guard_class(self, orgpc, box):
clsbox = self.cls_of_box(box)
- self.generate_guard(rop.GUARD_CLASS, box, [clsbox], resumepc=orgpc)
+ if box not in self.metainterp.known_class_boxes:
+ self.generate_guard(rop.GUARD_CLASS, box, [clsbox], resumepc=orgpc)
+ self.metainterp.known_class_boxes[box] = None
return clsbox
@arguments("int", "orgpc")
@@ -1251,7 +1256,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:
@@ -1467,6 +1472,8 @@
self.last_exc_value_box = None
self.retracing_loop_from = None
self.call_pure_results = args_dict_box()
+ # contains boxes where the class is already known
+ self.known_class_boxes = {}
def perform_call(self, jitcode, boxes, greenkey=None):
# causes the metainterp to enter the given subfunction
@@ -1807,6 +1814,8 @@
duplicates[box] = None
def reached_loop_header(self, greenboxes, redboxes, resumedescr):
+ self.known_class_boxes = {}
+
duplicates = {}
self.remove_consts_and_duplicates(redboxes, len(redboxes),
duplicates)
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -280,9 +280,6 @@
assert len(args) == 2
self._arg0, self._arg1 = args
- def getarglist(self):
- return [self._arg0, self._arg1, self._arg2]
-
def numargs(self):
return 2
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)
@@ -1021,6 +1021,69 @@
res = self.meta_interp(main, [])
assert res == 55
+ def test_dont_record_repeated_guard_class(self):
+ class A:
+ pass
+ class B(A):
+ pass
+ a = A()
+ b = B()
+ def fn(n):
+ if n == -7:
+ obj = None
+ elif n:
+ obj = a
+ else:
+ obj = b
+ return isinstance(obj, B) + isinstance(obj, B) + isinstance(obj, B) + isinstance(obj, B)
+ res = self.interp_operations(fn, [0])
+ assert res == 4
+ self.check_operations_history(guard_class=1, guard_nonnull=1)
+ res = self.interp_operations(fn, [1])
+ assert not res
+
+ def test_dont_record_guard_class_after_new(self):
+ class A:
+ pass
+ class B(A):
+ pass
+ def fn(n):
+ if n == -7:
+ obj = None
+ elif n:
+ obj = A()
+ else:
+ obj = B()
+ return isinstance(obj, B) + isinstance(obj, B) + isinstance(obj, B) + isinstance(obj, B)
+ res = self.interp_operations(fn, [0])
+ assert res == 4
+ self.check_operations_history(guard_class=0, guard_nonnull=0)
+ res = self.interp_operations(fn, [1])
+ assert not res
+
+ def test_guard_isnull_nullifies(self):
+ class A:
+ pass
+ a = A()
+ a.x = None
+ def fn(n):
+ if n == -7:
+ a.x = ""
+ obj = a.x
+ res = 0
+ if not obj:
+ res += 1
+ if obj:
+ res += 1
+ if obj is None:
+ res += 1
+ if obj is not None:
+ res += 1
+ return res
+ res = self.interp_operations(fn, [0])
+ assert res == 2
+ self.check_operations_history(guard_isnull=1)
+
def test_assert_isinstance(self):
class A:
pass
@@ -1252,7 +1315,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 +1375,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 +1406,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 +1440,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 +1559,7 @@
glob.a = B()
const = 2
else:
- const = hint(const, promote=True)
+ promote(const)
x -= const
res += a.x
a = None
@@ -1531,7 +1594,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 +1658,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])
@@ -1676,8 +1739,8 @@
return a1.val + b1.val
res = self.meta_interp(g, [6, 14])
assert res == g(6, 14)
- self.check_loop_count(9)
- self.check_loops(getarrayitem_gc=8, everywhere=True)
+ self.check_loop_count(8)
+ self.check_loops(getarrayitem_gc=7, everywhere=True)
py.test.skip("for the following, we need setarrayitem(varindex)")
self.check_loops(getarrayitem_gc=6, everywhere=True)
@@ -1817,7 +1880,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 +2065,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 +2110,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 +2145,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 +2202,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 +2271,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
@@ -2313,6 +2377,67 @@
assert res == -2
#self.check_loops(getarrayitem_gc=0, setarrayitem_gc=0) -- xxx?
+ def test_retrace_ending_up_retrazing_another_loop(self):
+
+ myjitdriver = JitDriver(greens = ['pc'], reds = ['n', 'i', 'sa'])
+ bytecode = "0+sI0+SI"
+ def f(n):
+ myjitdriver.set_param('threshold', 3)
+ myjitdriver.set_param('trace_eagerness', 1)
+ myjitdriver.set_param('retrace_limit', 5)
+ myjitdriver.set_param('function_threshold', -1)
+ pc = sa = i = 0
+ while pc < len(bytecode):
+ myjitdriver.jit_merge_point(pc=pc, n=n, sa=sa, i=i)
+ n = hint(n, promote=True)
+ op = bytecode[pc]
+ if op == '0':
+ i = 0
+ elif op == '+':
+ i += 1
+ elif op == 's':
+ sa += i
+ elif op == 'S':
+ sa += 2
+ elif op == 'I':
+ if i < n:
+ pc -= 2
+ myjitdriver.can_enter_jit(pc=pc, n=n, sa=sa, i=i)
+ continue
+ pc += 1
+ return sa
+
+ def g(n1, n2):
+ for i in range(10):
+ f(n1)
+ for i in range(10):
+ f(n2)
+
+ nn = [10, 3]
+ assert self.meta_interp(g, nn) == g(*nn)
+
+ # The attempts of retracing first loop will end up retracing the
+ # second and thus fail 5 times, saturating the retrace_count. Instead a
+ # bridge back to the preamble of the first loop is produced. A guard in
+ # this bridge is later traced resulting in a retrace of the second loop.
+ # Thus we end up with:
+ # 1 preamble and 1 specialized version of first loop
+ # 1 preamble and 2 specialized version of second loop
+ self.check_tree_loop_count(2 + 3)
+
+ # FIXME: Add a gloabl retrace counter and test that we are not trying more than 5 times.
+
+ def g(n):
+ for i in range(n):
+ for j in range(10):
+ f(n-i)
+
+ res = self.meta_interp(g, [10])
+ assert res == g(10)
+ # 1 preamble and 6 speciealized versions of each loop
+ self.check_tree_loop_count(2*(1 + 6))
+
+
class TestOOtype(BasicTests, OOJitMixin):
def test_oohash(self):
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/metainterp/warmstate.py b/pypy/jit/metainterp/warmstate.py
--- a/pypy/jit/metainterp/warmstate.py
+++ b/pypy/jit/metainterp/warmstate.py
@@ -237,7 +237,7 @@
d = {}
if NonConstant(False):
value = 'blah' # not a constant ''
- if value is None:
+ if value is None or value == 'all':
value = ALL_OPTS_NAMES
for name in value.split(":"):
if name:
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/jit/tool/oparser.py b/pypy/jit/tool/oparser.py
--- a/pypy/jit/tool/oparser.py
+++ b/pypy/jit/tool/oparser.py
@@ -337,6 +337,11 @@
num += 1
return num, ops, last_offset
+ def postprocess(self, loop):
+ """ A hook that can be overloaded to do some postprocessing
+ """
+ return loop
+
def parse_offset(self, line):
if line.startswith('+'):
# it begins with an offset, like: "+10: i1 = int_add(...)"
diff --git a/pypy/module/__builtin__/__init__.py b/pypy/module/__builtin__/__init__.py
--- a/pypy/module/__builtin__/__init__.py
+++ b/pypy/module/__builtin__/__init__.py
@@ -5,20 +5,6 @@
# put builtins here that should be optimized somehow
-OPTIMIZED_BUILTINS = ["len", "range", "xrange", "min", "max", "enumerate",
- "isinstance", "type", "zip", "file", "format", "open", "abs", "chr",
- "unichr", "ord", "pow", "repr", "hash", "oct", "hex", "round", "cmp",
- "getattr", "setattr", "delattr", "callable", "int", "str", "float"]
-
-assert len(OPTIMIZED_BUILTINS) <= 256
-
-BUILTIN_TO_INDEX = {}
-
-for i, name in enumerate(OPTIMIZED_BUILTINS):
- BUILTIN_TO_INDEX[name] = i
-
-assert len(OPTIMIZED_BUILTINS) == len(BUILTIN_TO_INDEX)
-
class Module(MixedModule):
"""Built-in functions, exceptions, and other objects."""
expose__file__attribute = False
@@ -141,9 +127,6 @@
def setup_after_space_initialization(self):
"""NOT_RPYTHON"""
space = self.space
- self.builtins_by_index = [None] * len(OPTIMIZED_BUILTINS)
- for i, name in enumerate(OPTIMIZED_BUILTINS):
- self.builtins_by_index[i] = space.getattr(self, space.wrap(name))
# install the more general version of isinstance() & co. in the space
from pypy.module.__builtin__ import abstractinst as ab
space.abstract_isinstance_w = ab.abstract_isinstance_w.__get__(space)
diff --git a/pypy/module/__builtin__/interp_classobj.py b/pypy/module/__builtin__/interp_classobj.py
--- a/pypy/module/__builtin__/interp_classobj.py
+++ b/pypy/module/__builtin__/interp_classobj.py
@@ -12,7 +12,7 @@
def raise_type_err(space, argument, expected, w_obj):
- type_name = space.type(w_obj).getname(space, '?')
+ type_name = space.type(w_obj).getname(space)
raise operationerrfmt(space.w_TypeError,
"argument %s must be %s, not %s",
argument, expected, type_name)
diff --git a/pypy/module/__builtin__/test/test_builtin.py b/pypy/module/__builtin__/test/test_builtin.py
--- a/pypy/module/__builtin__/test/test_builtin.py
+++ b/pypy/module/__builtin__/test/test_builtin.py
@@ -631,62 +631,6 @@
raises(TypeError, pr, end=3)
raises(TypeError, pr, sep=42)
-class AppTestBuiltinOptimized(object):
- def setup_class(cls):
- from pypy.conftest import gettestobjspace
- cls.space = gettestobjspace(**{"objspace.opcodes.CALL_LIKELY_BUILTIN": True})
-
- # hum, we need to invoke the compiler explicitely
- def test_xrange_len(self):
- s = """def test():
- x = xrange(33)
- assert len(x) == 33
- x = xrange(33.2)
- assert len(x) == 33
- x = xrange(33,0,-1)
- assert len(x) == 33
- x = xrange(33,0)
- assert len(x) == 0
- x = xrange(33,0.2)
- assert len(x) == 0
- x = xrange(0,33)
- assert len(x) == 33
- x = xrange(0,33,-1)
- assert len(x) == 0
- x = xrange(0,33,2)
- assert len(x) == 17
- x = xrange(0,32,2)
- assert len(x) == 16
- """
- ns = {}
- exec s in ns
- ns["test"]()
-
- def test_delete_from_builtins(self):
- s = """ """
- # XXX write this test!
-
- def test_shadow_case_bound_method(self):
- s = """def test(l):
- n = len(l)
- old_len = len
- class A(object):
- x = 5
- def length(self, o):
- return self.x*old_len(o)
- import __builtin__
- __builtin__.len = A().length
- try:
- m = len(l)
- finally:
- __builtin__.len = old_len
- return n+m
- """
- ns = {}
- exec s in ns
- res = ns["test"]([2,3,4])
- assert res == 18
-
def test_round(self):
assert round(11.234) == 11.0
assert round(11.234, -1) == 10.0
diff --git a/pypy/module/__builtin__/test/test_classobj.py b/pypy/module/__builtin__/test/test_classobj.py
--- a/pypy/module/__builtin__/test/test_classobj.py
+++ b/pypy/module/__builtin__/test/test_classobj.py
@@ -987,9 +987,9 @@
if option.runappdirect:
py.test.skip("can only be run on py.py")
def is_strdict(space, w_class):
- from pypy.objspace.std.dictmultiobject import StrDictImplementation
+ from pypy.objspace.std.dictmultiobject import StringDictStrategy
w_d = w_class.getdict(space)
- return space.wrap(isinstance(w_d, StrDictImplementation) and w_d.r_dict_content is None)
+ return space.wrap(isinstance(w_d.strategy, StringDictStrategy))
cls.w_is_strdict = cls.space.wrap(gateway.interp2app(is_strdict))
diff --git a/pypy/module/_codecs/interp_codecs.py b/pypy/module/_codecs/interp_codecs.py
--- a/pypy/module/_codecs/interp_codecs.py
+++ b/pypy/module/_codecs/interp_codecs.py
@@ -186,7 +186,7 @@
text = u'\ufffd' * size
return space.newtuple([space.wrap(text), w_end])
else:
- typename = space.type(w_exc).getname(space, '?')
+ typename = space.type(w_exc).getname(space)
raise operationerrfmt(space.w_TypeError,
"don't know how to handle %s in error callback", typename)
@@ -207,7 +207,7 @@
pos += 1
return space.newtuple([space.wrap(builder.build()), w_end])
else:
- typename = space.type(w_exc).getname(space, '?')
+ typename = space.type(w_exc).getname(space)
raise operationerrfmt(space.w_TypeError,
"don't know how to handle %s in error callback", typename)
@@ -240,7 +240,7 @@
pos += 1
return space.newtuple([space.wrap(builder.build()), w_end])
else:
- typename = space.type(w_exc).getname(space, '?')
+ typename = space.type(w_exc).getname(space)
raise operationerrfmt(space.w_TypeError,
"don't know how to handle %s in error callback", typename)
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/_io/interp_bufferedio.py b/pypy/module/_io/interp_bufferedio.py
--- a/pypy/module/_io/interp_bufferedio.py
+++ b/pypy/module/_io/interp_bufferedio.py
@@ -175,7 +175,7 @@
return space.call_method(self.w_raw, "isatty")
def repr_w(self, space):
- typename = space.type(self).getname(space, '?')
+ typename = space.type(self).getname(space)
module = space.str_w(space.type(self).get_module())
try:
w_name = space.getattr(self, space.wrap("name"))
diff --git a/pypy/module/_io/interp_io.py b/pypy/module/_io/interp_io.py
--- a/pypy/module/_io/interp_io.py
+++ b/pypy/module/_io/interp_io.py
@@ -119,7 +119,7 @@
if buffering < 0:
buffering = DEFAULT_BUFFER_SIZE
- if "st_blksize" in STAT_FIELD_TYPES:
+ if space.config.translation.type_system == 'lltype' and 'st_blksize' in STAT_FIELD_TYPES:
fileno = space.int_w(space.call_method(w_raw, "fileno"))
try:
st = os.fstat(fileno)
diff --git a/pypy/module/_io/interp_iobase.py b/pypy/module/_io/interp_iobase.py
--- a/pypy/module/_io/interp_iobase.py
+++ b/pypy/module/_io/interp_iobase.py
@@ -155,7 +155,7 @@
raise operationerrfmt(
space.w_IOError,
"peek() should have returned a bytes object, "
- "not '%s'", space.type(w_readahead).getname(space, '?'))
+ "not '%s'", space.type(w_readahead).getname(space))
length = space.len_w(w_readahead)
if length > 0:
n = 0
@@ -181,7 +181,7 @@
raise operationerrfmt(
space.w_IOError,
"peek() should have returned a bytes object, "
- "not '%s'", space.type(w_read).getname(space, '?'))
+ "not '%s'", space.type(w_read).getname(space))
read = space.str_w(w_read)
if not read:
break
diff --git a/pypy/module/_io/interp_stringio.py b/pypy/module/_io/interp_stringio.py
--- a/pypy/module/_io/interp_stringio.py
+++ b/pypy/module/_io/interp_stringio.py
@@ -129,7 +129,7 @@
if not space.isinstance_w(w_obj, space.w_unicode):
raise operationerrfmt(space.w_TypeError,
"string argument expected, got '%s'",
- space.type(w_obj).getname(space, '?'))
+ space.type(w_obj).getname(space))
self._check_closed(space)
orig_size = space.len_w(w_obj)
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)
@@ -212,7 +212,7 @@
module += '.'
return '{%s%s}' % (module, w_arg.name)
else:
- class_name = space.type(w_arg).getname(space, '?')
+ class_name = space.type(w_arg).getname(space)
return "{'%s' object}" % (class_name,)
def lsprof_call(space, w_self, frame, event, w_arg):
@@ -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/_lsprof/test/test_cprofile.py b/pypy/module/_lsprof/test/test_cprofile.py
--- a/pypy/module/_lsprof/test/test_cprofile.py
+++ b/pypy/module/_lsprof/test/test_cprofile.py
@@ -181,8 +181,7 @@
class AppTestWithDifferentBytecodes(AppTestCProfile):
- keywords = {'objspace.opcodes.CALL_LIKELY_BUILTIN': True,
- 'objspace.opcodes.CALL_METHOD': True}
+ keywords = {'objspace.opcodes.CALL_METHOD': True}
expected_output = {}
diff --git a/pypy/module/_multiprocessing/interp_connection.py b/pypy/module/_multiprocessing/interp_connection.py
--- a/pypy/module/_multiprocessing/interp_connection.py
+++ b/pypy/module/_multiprocessing/interp_connection.py
@@ -360,7 +360,7 @@
conn_type = ["read-only", "write-only", "read-write"][self.flags]
return space.wrap("<%s %s, handle %zd>" % (
- conn_type, space.type(self).getname(space, '?'), self.do_fileno()))
+ conn_type, space.type(self).getname(space), self.do_fileno()))
def is_valid(self):
return self.handle != self.INVALID_HANDLE_VALUE
diff --git a/pypy/module/_stackless/interp_coroutine.py b/pypy/module/_stackless/interp_coroutine.py
--- a/pypy/module/_stackless/interp_coroutine.py
+++ b/pypy/module/_stackless/interp_coroutine.py
@@ -40,7 +40,7 @@
raise operationerrfmt(
space.w_TypeError,
"'%s' object is not callable",
- space.type(w_obj).getname(space, '?'))
+ space.type(w_obj).getname(space))
self.w_func = w_obj
self.args = args
diff --git a/pypy/module/_weakref/interp__weakref.py b/pypy/module/_weakref/interp__weakref.py
--- a/pypy/module/_weakref/interp__weakref.py
+++ b/pypy/module/_weakref/interp__weakref.py
@@ -129,7 +129,7 @@
if w_obj is None:
state = '; dead'
else:
- typename = space.type(w_obj).getname(space, '?')
+ typename = space.type(w_obj).getname(space)
objname = w_obj.getname(space, '')
if objname:
state = "; to '%s' (%s)" % (typename, objname)
diff --git a/pypy/module/array/interp_array.py b/pypy/module/array/interp_array.py
--- a/pypy/module/array/interp_array.py
+++ b/pypy/module/array/interp_array.py
@@ -1,18 +1,21 @@
from __future__ import with_statement
+from pypy.interpreter.baseobjspace import Wrappable
+from pypy.interpreter.buffer import RWBuffer
from pypy.interpreter.error import OperationError
+from pypy.interpreter.gateway import interp2app, unwrap_spec
from pypy.interpreter.typedef import TypeDef, GetSetProperty, make_weakref_descr
-from pypy.rpython.lltypesystem import lltype, rffi
-from pypy.interpreter.gateway import interp2app, unwrap_spec
-from pypy.rlib.unroll import unrolling_iterable
-from pypy.rlib.rarithmetic import ovfcheck
-from pypy.interpreter.baseobjspace import Wrappable
+from pypy.module._file.interp_file import W_File
+from pypy.objspace.std.model import W_Object
+from pypy.objspace.std.multimethod import FailedToImplement
from pypy.objspace.std.stdtypedef import SMM, StdTypeDef
from pypy.objspace.std.register_all import register_all
-from pypy.objspace.std.model import W_Object
-from pypy.module._file.interp_file import W_File
-from pypy.interpreter.buffer import RWBuffer
-from pypy.objspace.std.multimethod import FailedToImplement
+from pypy.rlib.rarithmetic import ovfcheck
+from pypy.rlib.unroll import unrolling_iterable
+from pypy.rpython.lltypesystem import lltype, rffi
+
+
+memcpy = rffi.llexternal("memcpy", [rffi.VOIDP, rffi.VOIDP, rffi.SIZE_T], lltype.Void)
@unwrap_spec(typecode=str)
def w_array(space, w_cls, typecode, __args__):
@@ -37,7 +40,7 @@
if len(__args__.arguments_w) > 0:
w_initializer = __args__.arguments_w[0]
if space.type(w_initializer) is space.w_str:
- a.fromstring(w_initializer)
+ a.fromstring(space.str_w(w_initializer))
elif space.type(w_initializer) is space.w_unicode:
a.fromsequence(w_initializer)
elif space.type(w_initializer) is space.w_list:
@@ -73,6 +76,7 @@
array_buffer_info = SMM('buffer_info', 1)
array_reduce = SMM('__reduce__', 1)
+array_copy = SMM('__copy__', 1)
array_byteswap = SMM('byteswap', 1)
@@ -96,7 +100,7 @@
itemsize = GetSetProperty(descr_itemsize),
typecode = GetSetProperty(descr_typecode),
__weakref__ = make_weakref_descr(W_ArrayBase),
- )
+)
W_ArrayBase.typedef.registermethods(globals())
@@ -159,8 +163,6 @@
self.data[index] = char
-
-
def make_array(mytype):
class W_Array(W_ArrayBase):
itemsize = mytype.bytes
@@ -268,12 +270,10 @@
raise
self.setlen(oldlen + i)
- def fromstring(self, w_s):
- space = self.space
- s = space.str_w(w_s)
+ def fromstring(self, s):
if len(s) % self.itemsize != 0:
msg = 'string length not a multiple of item size'
- raise OperationError(space.w_ValueError, space.wrap(msg))
+ raise OperationError(self.space.w_ValueError, self.space.wrap(msg))
oldlen = self.len
new = len(s) / mytype.bytes
self.setlen(oldlen + new)
@@ -311,6 +311,14 @@
def charbuf(self):
return rffi.cast(rffi.CCHARP, self.buffer)
+ def w_getitem(self, space, idx):
+ item = self.buffer[idx]
+ if mytype.typecode in 'bBhHil':
+ item = rffi.cast(lltype.Signed, item)
+ elif mytype.typecode == 'f':
+ item = float(item)
+ return space.wrap(item)
+
# Basic get/set/append/extend methods
def len__Array(space, self):
@@ -319,12 +327,7 @@
def getitem__Array_ANY(space, self, w_idx):
idx, stop, step = space.decode_index(w_idx, self.len)
assert step == 0
- item = self.buffer[idx]
- if mytype.typecode in 'bBhHil':
- item = rffi.cast(lltype.Signed, item)
- elif mytype.typecode == 'f':
- item = float(item)
- return self.space.wrap(item)
+ return self.w_getitem(space, idx)
def getitem__Array_Slice(space, self, w_slice):
start, stop, step, size = space.decode_index4(w_slice, self.len)
@@ -387,7 +390,7 @@
def array_count__Array_ANY(space, self, w_val):
cnt = 0
for i in range(self.len):
- w_item = getitem__Array_ANY(space, self, space.wrap(i))
+ w_item = self.w_getitem(space, i)
if space.is_true(space.eq(w_item, w_val)):
cnt += 1
return space.wrap(cnt)
@@ -395,7 +398,7 @@
def array_index__Array_ANY(space, self, w_val):
cnt = 0
for i in range(self.len):
- w_item = getitem__Array_ANY(space, self, space.wrap(i))
+ w_item = self.w_getitem(space, i)
if space.is_true(space.eq(w_item, w_val)):
return space.wrap(i)
msg = 'array.index(x): x not in list'
@@ -413,7 +416,7 @@
if i < 0 or i >= self.len:
msg = 'pop index out of range'
raise OperationError(space.w_IndexError, space.wrap(msg))
- w_val = getitem__Array_ANY(space, self, space.wrap(i))
+ w_val = self.w_getitem(space, i)
while i < self.len - 1:
self.buffer[i] = self.buffer[i + 1]
i += 1
@@ -515,14 +518,14 @@
def array_tolist__Array(space, self):
w_l = space.newlist([])
for i in range(self.len):
- w_l.append(getitem__Array_ANY(space, self, space.wrap(i)))
+ w_l.append(self.w_getitem(space, i))
return w_l
def array_fromlist__Array_List(space, self, w_lst):
self.fromlist(w_lst)
def array_fromstring__Array_ANY(space, self, w_s):
- self.fromstring(w_s)
+ self.fromstring(space.str_w(w_s))
def array_tostring__Array(space, self):
cbuf = self.charbuf()
@@ -615,6 +618,16 @@
dct = space.w_None
return space.newtuple([space.type(self), space.newtuple(args), dct])
+ def array_copy__Array(space, self):
+ w_a = mytype.w_class(self.space)
+ w_a.setlen(self.len)
+ memcpy(
+ rffi.cast(rffi.VOIDP, w_a.buffer),
+ rffi.cast(rffi.VOIDP, self.buffer),
+ self.len * mytype.bytes
+ )
+ return w_a
+
def array_byteswap__Array(space, self):
if mytype.bytes not in [1, 2, 4, 8]:
msg = "byteswap not supported for this array"
diff --git a/pypy/module/cpyext/methodobject.py b/pypy/module/cpyext/methodobject.py
--- a/pypy/module/cpyext/methodobject.py
+++ b/pypy/module/cpyext/methodobject.py
@@ -122,7 +122,7 @@
return self.space.unwrap(self.descr_method_repr())
def descr_method_repr(self):
- return self.getrepr(self.space, "built-in method '%s' of '%s' object" % (self.name, self.w_objclass.getname(self.space, '?')))
+ return self.getrepr(self.space, "built-in method '%s' of '%s' object" % (self.name, self.w_objclass.getname(self.space)))
PyCFunction_Check, PyCFunction_CheckExact = build_type_checkers("CFunction", W_PyCFunctionObject)
@@ -151,7 +151,7 @@
def descr_method_repr(self):
return self.space.wrap("<slot wrapper '%s' of '%s' objects>" % (self.method_name,
- self.w_objclass.getname(self.space, '?')))
+ self.w_objclass.getname(self.space)))
def cwrapper_descr_call(space, w_self, __args__):
self = space.interp_w(W_PyCWrapperObject, w_self)
diff --git a/pypy/module/cpyext/typeobject.py b/pypy/module/cpyext/typeobject.py
--- a/pypy/module/cpyext/typeobject.py
+++ b/pypy/module/cpyext/typeobject.py
@@ -450,7 +450,7 @@
PyObject_Del.api_func.get_wrapper(space))
pto.c_tp_alloc = llhelper(PyType_GenericAlloc.api_func.functype,
PyType_GenericAlloc.api_func.get_wrapper(space))
- pto.c_tp_name = rffi.str2charp(w_type.getname(space, "?"))
+ pto.c_tp_name = rffi.str2charp(w_type.getname(space))
pto.c_tp_basicsize = -1 # hopefully this makes malloc bail out
pto.c_tp_itemsize = 0
# uninitialized fields:
diff --git a/pypy/module/exceptions/interp_exceptions.py b/pypy/module/exceptions/interp_exceptions.py
--- a/pypy/module/exceptions/interp_exceptions.py
+++ b/pypy/module/exceptions/interp_exceptions.py
@@ -136,7 +136,7 @@
args_repr = space.str_w(space.repr(space.newtuple(self.args_w)))
else:
args_repr = "()"
- clsname = self.getclass(space).getname(space, '?')
+ clsname = self.getclass(space).getname(space)
return space.wrap(clsname + args_repr)
def descr_getargs(self, space):
@@ -546,7 +546,7 @@
w_tuple = space.newtuple(values_w + [self.w_lastlineno])
args_w = [self.args_w[0], w_tuple]
args_repr = space.str_w(space.repr(space.newtuple(args_w)))
- clsname = self.getclass(space).getname(space, '?')
+ clsname = self.getclass(space).getname(space)
return space.wrap(clsname + args_repr)
else:
return W_StandardError.descr_repr(self, space)
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:
@@ -799,14 +799,13 @@
"""
-# XXX picking a magic number is a mess. So far it works because we
-# have only two extra opcodes, which bump the magic number by +1 and
-# +2 respectively, and CPython leaves a gap of 10 when it increases
+# picking a magic number is a mess. So far it works because we
+# have only one extra opcode, which bumps the magic number by +2, and CPython
+# leaves a gap of 10 when it increases
# its own magic number. To avoid assigning exactly the same numbers
# as CPython we always add a +2. We'll have to think again when we
-# get at the fourth new opcode :-(
+# get three more new opcodes
#
-# * CALL_LIKELY_BUILTIN +1
# * CALL_METHOD +2
#
# In other words:
@@ -829,8 +828,6 @@
return struct.unpack('<i', magic)[0]
result = default_magic
- if space.config.objspace.opcodes.CALL_LIKELY_BUILTIN:
- result += 1
if space.config.objspace.opcodes.CALL_METHOD:
result += 2
return result
diff --git a/pypy/module/micronumpy/__init__.py b/pypy/module/micronumpy/__init__.py
--- a/pypy/module/micronumpy/__init__.py
+++ b/pypy/module/micronumpy/__init__.py
@@ -10,6 +10,7 @@
'zeros': 'interp_numarray.zeros',
'empty': 'interp_numarray.zeros',
'ones': 'interp_numarray.ones',
+ 'fromstring': 'interp_support.fromstring',
# ufuncs
'abs': 'interp_ufuncs.absolute',
diff --git a/pypy/module/micronumpy/compile.py b/pypy/module/micronumpy/compile.py
--- a/pypy/module/micronumpy/compile.py
+++ b/pypy/module/micronumpy/compile.py
@@ -40,6 +40,11 @@
elif b == '/':
right = stack.pop()
stack.append(stack.pop().descr_div(space, right))
+ elif b == '%':
+ right = stack.pop()
+ stack.append(stack.pop().descr_mod(space, right))
+ elif b == '|':
+ stack.append(stack.pop().descr_abs(space))
else:
print "Unknown opcode: %s" % b
raise BogusBytecode()
diff --git a/pypy/module/micronumpy/interp_numarray.py b/pypy/module/micronumpy/interp_numarray.py
--- a/pypy/module/micronumpy/interp_numarray.py
+++ b/pypy/module/micronumpy/interp_numarray.py
@@ -5,6 +5,7 @@
from pypy.rlib import jit
from pypy.rpython.lltypesystem import lltype
from pypy.tool.sourcetools import func_with_new_name
+import math
def dummy1(v):
@@ -30,6 +31,12 @@
self.transitions[target] = new = Signature()
return new
+def pos(v):
+ return v
+def neg(v):
+ return -v
+def absolute(v):
+ return abs(v)
def add(v1, v2):
return v1 + v2
def sub(v1, v2):
@@ -38,6 +45,10 @@
return v1 * v2
def div(v1, v2):
return v1 / v2
+def pow(v1, v2):
+ return math.pow(v1, v2)
+def mod(v1, v2):
+ return math.fmod(v1, v2)
class BaseArray(Wrappable):
def __init__(self):
@@ -52,6 +63,22 @@
arr.force_if_needed()
del self.invalidates[:]
+ def _unop_impl(function):
+ signature = Signature()
+ def impl(self, space):
+ new_sig = self.signature.transition(signature)
+ res = Call1(
+ function,
+ self,
+ new_sig)
+ self.invalidates.append(res)
+ return space.wrap(res)
+ return func_with_new_name(impl, "uniop_%s_impl" % function.__name__)
+
+ descr_pos = _unop_impl(pos)
+ descr_neg = _unop_impl(neg)
+ descr_abs = _unop_impl(absolute)
+
def _binop_impl(function):
signature = Signature()
def impl(self, space, w_other):
@@ -80,6 +107,8 @@
descr_sub = _binop_impl(sub)
descr_mul = _binop_impl(mul)
descr_div = _binop_impl(div)
+ descr_pow = _binop_impl(pow)
+ descr_mod = _binop_impl(mod)
def get_concrete(self):
raise NotImplementedError
@@ -351,10 +380,15 @@
__getitem__ = interp2app(BaseArray.descr_getitem),
__setitem__ = interp2app(BaseArray.descr_setitem),
+ __pos__ = interp2app(BaseArray.descr_pos),
+ __neg__ = interp2app(BaseArray.descr_neg),
+ __abs__ = interp2app(BaseArray.descr_abs),
__add__ = interp2app(BaseArray.descr_add),
__sub__ = interp2app(BaseArray.descr_sub),
__mul__ = interp2app(BaseArray.descr_mul),
__div__ = interp2app(BaseArray.descr_div),
+ __pow__ = interp2app(BaseArray.descr_pow),
+ __mod__ = interp2app(BaseArray.descr_mod),
mean = interp2app(BaseArray.descr_mean),
)
diff --git a/pypy/module/micronumpy/interp_support.py b/pypy/module/micronumpy/interp_support.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/micronumpy/interp_support.py
@@ -0,0 +1,32 @@
+
+from pypy.rlib.rstruct.runpack import runpack
+from pypy.rpython.lltypesystem import lltype, rffi
+from pypy.interpreter.gateway import unwrap_spec
+from pypy.interpreter.error import OperationError
+from pypy.module.micronumpy.interp_numarray import SingleDimArray
+
+FLOAT_SIZE = rffi.sizeof(lltype.Float)
+
+ at unwrap_spec(s=str)
+def fromstring(space, s):
+ length = len(s)
+
+ if length % FLOAT_SIZE == 0:
+ number = length/FLOAT_SIZE
+ else:
+ raise OperationError(space.w_ValueError, space.wrap(
+ "string length %d not divisable by %d" % (length, FLOAT_SIZE)))
+
+ a = SingleDimArray(number)
+
+ start = 0
+ end = FLOAT_SIZE
+ i = 0
+ while i < number:
+ part = s[start:end]
+ a.storage[i] = runpack('d', part)
+ i += 1
+ start += FLOAT_SIZE
+ end += FLOAT_SIZE
+
+ return space.wrap(a)
diff --git a/pypy/module/micronumpy/test/test_numarray.py b/pypy/module/micronumpy/test/test_numarray.py
--- a/pypy/module/micronumpy/test/test_numarray.py
+++ b/pypy/module/micronumpy/test/test_numarray.py
@@ -1,6 +1,7 @@
import py
from pypy.module.micronumpy.test.test_base import BaseNumpyAppTest
+from pypy.conftest import gettestobjspace
class AppTestNumArray(BaseNumpyAppTest):
@@ -154,6 +155,72 @@
for i in range(5):
assert b[i] == i / 5.0
+ def test_pow(self):
+ from numpy import array
+ a = array(range(5))
+ b = a ** a
+ for i in range(5):
+ print b[i], i**i
+ assert b[i] == i**i
+
+ def test_pow_other(self):
+ from numpy import array
+ a = array(range(5))
+ b = array([2, 2, 2, 2, 2])
+ c = a ** b
+ for i in range(5):
+ assert c[i] == i ** 2
+
+ def test_pow_constant(self):
+ from numpy import array
+ a = array(range(5))
+ b = a ** 2
+ for i in range(5):
+ assert b[i] == i ** 2
+
+ def test_mod(self):
+ from numpy import array
+ a = array(range(1,6))
+ b = a % a
+ for i in range(5):
+ assert b[i] == 0
+
+ def test_mod_other(self):
+ from numpy import array
+ a = array(range(5))
+ b = array([2, 2, 2, 2, 2])
+ c = a % b
+ for i in range(5):
+ assert c[i] == i % 2
+
+ def test_mod_constant(self):
+ from numpy import array
+ a = array(range(5))
+ b = a % 2
+ for i in range(5):
+ assert b[i] == i % 2
+
+ def test_pos(self):
+ from numpy import array
+ a = array([1.,-2.,3.,-4.,-5.])
+ b = +a
+ for i in range(5):
+ assert b[i] == a[i]
+
+ def test_neg(self):
+ from numpy import array
+ a = array([1.,-2.,3.,-4.,-5.])
+ b = -a
+ for i in range(5):
+ assert b[i] == -a[i]
+
+ def test_abs(self):
+ from numpy import array
+ a = array([1.,-2.,3.,-4.,-5.])
+ b = abs(a)
+ for i in range(5):
+ assert b[i] == abs(a[i])
+
def test_auto_force(self):
from numpy import array
a = array(range(5))
@@ -210,7 +277,21 @@
assert d[1] == 12
def test_mean(self):
- from numpy import array, mean
+ from numpy import array
a = array(range(5))
assert a.mean() == 2.0
- assert a[:4].mean() == 1.5
\ No newline at end of file
+ assert a[:4].mean() == 1.5
+
+class AppTestSupport(object):
+ def setup_class(cls):
+ import struct
+ cls.space = gettestobjspace(usemodules=('micronumpy',))
+ cls.w_data = cls.space.wrap(struct.pack('dddd', 1, 2, 3, 4))
+
+ def test_fromstring(self):
+ from numpy import fromstring
+ a = fromstring(self.data)
+ for i in range(4):
+ assert a[i] == i + 1
+ raises(ValueError, fromstring, "abc")
+
diff --git a/pypy/module/micronumpy/test/test_zjit.py b/pypy/module/micronumpy/test/test_zjit.py
--- a/pypy/module/micronumpy/test/test_zjit.py
+++ b/pypy/module/micronumpy/test/test_zjit.py
@@ -1,7 +1,7 @@
from pypy.jit.metainterp.test.support import LLJitMixin
from pypy.rpython.test.test_llinterp import interpret
from pypy.module.micronumpy.interp_numarray import (SingleDimArray, Signature,
- FloatWrapper, Call1, Call2, SingleDimSlice, add, mul)
+ FloatWrapper, Call2, SingleDimSlice, add, mul, neg, Call1)
from pypy.module.micronumpy.interp_ufuncs import negative
from pypy.module.micronumpy.compile import numpy_compile
@@ -13,8 +13,6 @@
cls.space = FakeSpace()
def test_add(self):
- space = self.space
-
def f(i):
ar = SingleDimArray(i)
v = Call2(add, ar, ar, Signature())
@@ -27,8 +25,6 @@
assert result == f(5)
def test_floatadd(self):
- space = self.space
-
def f(i):
ar = SingleDimArray(i)
v = Call2(add, ar, FloatWrapper(4.5), Signature())
@@ -40,11 +36,24 @@
"int_lt": 1, "guard_true": 1, "jump": 1})
assert result == f(5)
- def test_already_forecd(self):
+ def test_neg(self):
space = self.space
def f(i):
ar = SingleDimArray(i)
+ v = Call1(neg, ar, Signature())
+ return v.get_concrete().storage[3]
+
+ result = self.meta_interp(f, [5], listops=True, backendopt=True)
+ self.check_loops({"getarrayitem_raw": 1, "float_neg": 1,
+ "setarrayitem_raw": 1, "int_add": 1,
+ "int_lt": 1, "guard_true": 1, "jump": 1})
+
+ assert result == f(5)
+
+ def test_already_forecd(self):
+ def f(i):
+ ar = SingleDimArray(i)
v1 = Call2(add, ar, FloatWrapper(4.5), Signature())
v2 = Call2(mul, v1, FloatWrapper(4.5), Signature())
v1.force_if_needed()
@@ -95,8 +104,6 @@
self.check_loop_count(3)
def test_slice(self):
- space = self.space
-
def f(i):
step = 3
ar = SingleDimArray(step*i)
@@ -111,8 +118,6 @@
assert result == f(5)
def test_slice2(self):
- space = self.space
-
def f(i):
step1 = 2
step2 = 3
diff --git a/pypy/module/oracle/interp_variable.py b/pypy/module/oracle/interp_variable.py
--- a/pypy/module/oracle/interp_variable.py
+++ b/pypy/module/oracle/interp_variable.py
@@ -1484,7 +1484,7 @@
raise OperationError(
moduledict.w_NotSupportedError,
space.wrap("Variable_TypeByValue(): unhandled data type %s" %
- (space.type(w_value).getname(space, '?'),)))
+ (space.type(w_value).getname(space),)))
def newByInputTypeHandler(space, cursor, w_inputTypeHandler, w_value, numElements):
w_var = space.call(w_inputTypeHandler,
diff --git a/pypy/module/pyexpat/__init__.py b/pypy/module/pyexpat/__init__.py
--- a/pypy/module/pyexpat/__init__.py
+++ b/pypy/module/pyexpat/__init__.py
@@ -2,6 +2,22 @@
from pypy.interpreter.mixedmodule import MixedModule
+class ErrorsModule(MixedModule):
+ "Definition of pyexpat.errors module."
+
+ appleveldefs = {
+ }
+
+ interpleveldefs = {
+ }
+
+ def setup_after_space_initialization(self):
+ from pypy.module.pyexpat import interp_pyexpat
+ for name in interp_pyexpat.xml_error_list:
+ self.space.setattr(self, self.space.wrap(name),
+ interp_pyexpat.ErrorString(self.space,
+ getattr(interp_pyexpat, name)))
+
class Module(MixedModule):
"Python wrapper for Expat parser."
@@ -21,6 +37,10 @@
'version_info': 'interp_pyexpat.get_expat_version_info(space)',
}
+ submodules = {
+ 'errors': ErrorsModule,
+ }
+
for name in ['XML_PARAM_ENTITY_PARSING_NEVER',
'XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE',
'XML_PARAM_ENTITY_PARSING_ALWAYS']:
diff --git a/pypy/module/pyexpat/interp_pyexpat.py b/pypy/module/pyexpat/interp_pyexpat.py
--- a/pypy/module/pyexpat/interp_pyexpat.py
+++ b/pypy/module/pyexpat/interp_pyexpat.py
@@ -31,6 +31,48 @@
XML_Content_Ptr = lltype.Ptr(lltype.ForwardReference())
XML_Parser = rffi.COpaquePtr(typedef='XML_Parser')
+xml_error_list = [
+ "XML_ERROR_NO_MEMORY",
+ "XML_ERROR_SYNTAX",
+ "XML_ERROR_NO_ELEMENTS",
+ "XML_ERROR_INVALID_TOKEN",
+ "XML_ERROR_UNCLOSED_TOKEN",
+ "XML_ERROR_PARTIAL_CHAR",
+ "XML_ERROR_TAG_MISMATCH",
+ "XML_ERROR_DUPLICATE_ATTRIBUTE",
+ "XML_ERROR_JUNK_AFTER_DOC_ELEMENT",
+ "XML_ERROR_PARAM_ENTITY_REF",
+ "XML_ERROR_UNDEFINED_ENTITY",
+ "XML_ERROR_RECURSIVE_ENTITY_REF",
+ "XML_ERROR_ASYNC_ENTITY",
+ "XML_ERROR_BAD_CHAR_REF",
+ "XML_ERROR_BINARY_ENTITY_REF",
+ "XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF",
+ "XML_ERROR_MISPLACED_XML_PI",
+ "XML_ERROR_UNKNOWN_ENCODING",
+ "XML_ERROR_INCORRECT_ENCODING",
+ "XML_ERROR_UNCLOSED_CDATA_SECTION",
+ "XML_ERROR_EXTERNAL_ENTITY_HANDLING",
+ "XML_ERROR_NOT_STANDALONE",
+ "XML_ERROR_UNEXPECTED_STATE",
+ "XML_ERROR_ENTITY_DECLARED_IN_PE",
+ "XML_ERROR_FEATURE_REQUIRES_XML_DTD",
+ "XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING",
+ # Added in Expat 1.95.7.
+ "XML_ERROR_UNBOUND_PREFIX",
+ # Added in Expat 1.95.8.
+ "XML_ERROR_UNDECLARING_PREFIX",
+ "XML_ERROR_INCOMPLETE_PE",
+ "XML_ERROR_XML_DECL",
+ "XML_ERROR_TEXT_DECL",
+ "XML_ERROR_PUBLICID",
+ "XML_ERROR_SUSPENDED",
+ "XML_ERROR_NOT_SUSPENDED",
+ "XML_ERROR_ABORTED",
+ "XML_ERROR_FINISHED",
+ "XML_ERROR_SUSPEND_PE",
+ ]
+
class CConfigure:
_compilation_info_ = eci
XML_Content = rffi_platform.Struct('XML_Content', [
@@ -56,6 +98,9 @@
XML_FALSE = rffi_platform.ConstantInteger('XML_FALSE')
XML_TRUE = rffi_platform.ConstantInteger('XML_TRUE')
+ for name in xml_error_list:
+ locals()[name] = rffi_platform.ConstantInteger(name)
+
for k, v in rffi_platform.configure(CConfigure).items():
globals()[k] = v
@@ -298,7 +343,8 @@
XML_GetErrorCode = expat_external(
'XML_GetErrorCode', [XML_Parser], rffi.INT)
XML_ErrorString = expat_external(
- 'XML_ErrorString', [rffi.INT], rffi.CCHARP)
+ 'XML_ErrorString', [rffi.INT],
+ rffi.CCHARP)
XML_GetCurrentLineNumber = expat_external(
'XML_GetCurrentLineNumber', [XML_Parser], rffi.INT)
XML_GetErrorLineNumber = XML_GetCurrentLineNumber
@@ -691,7 +737,7 @@
elif space.is_true(space.isinstance(w_encoding, space.w_str)):
encoding = space.str_w(w_encoding)
else:
- type_name = space.type(w_encoding).getname(space, '?')
+ type_name = space.type(w_encoding).getname(space)
raise OperationError(
space.w_TypeError,
space.wrap('ParserCreate() argument 1 must be string or None,'
@@ -711,7 +757,7 @@
space.wrap('namespace_separator must be at most one character,'
' omitted, or None'))
else:
- type_name = space.type(w_namespace_separator).getname(space, '?')
+ type_name = space.type(w_namespace_separator).getname(space)
raise OperationError(
space.w_TypeError,
space.wrap('ParserCreate() argument 2 must be string or None,'
diff --git a/pypy/module/pyexpat/test/test_parser.py b/pypy/module/pyexpat/test/test_parser.py
--- a/pypy/module/pyexpat/test/test_parser.py
+++ b/pypy/module/pyexpat/test/test_parser.py
@@ -38,7 +38,7 @@
parser = pyexpat.ParserCreate()
raises(pyexpat.ExpatError, "parser.Parse(xml, True)")
- def test_encoding(self):
+ def test_encoding_argument(self):
import pyexpat
for encoding_arg in (None, 'utf-8', 'iso-8859-1'):
for namespace_arg in (None, '{'):
@@ -68,7 +68,7 @@
assert p.buffer_size == 150
raises(TypeError, setattr, p, 'buffer_size', sys.maxint + 1)
- def test_encoding(self):
+ def test_encoding_xml(self):
# use one of the few encodings built-in in expat
xml = "<?xml version='1.0' encoding='iso-8859-1'?><s>caf\xe9</s>"
import pyexpat
@@ -120,3 +120,14 @@
return True
p.ExternalEntityRefHandler = handler
p.Parse(xml)
+
+ def test_errors(self):
+ import types
+ import pyexpat
+ assert isinstance(pyexpat.errors, types.ModuleType)
+ # check a few random errors
+ assert pyexpat.errors.XML_ERROR_SYNTAX == 'syntax error'
+ assert (pyexpat.errors.XML_ERROR_INCORRECT_ENCODING ==
+ 'encoding specified in XML declaration is incorrect')
+ assert (pyexpat.errors.XML_ERROR_XML_DECL ==
+ 'XML declaration not well-formed')
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
@@ -176,6 +176,8 @@
'''Configure the tunable JIT parameters.
* set_param(name=value, ...) # as keyword arguments
* set_param("name=value,name=value") # as a user-supplied string
+ * set_param("off") # disable the jit
+ * set_param("default") # restore all defaults
'''
# XXXXXXXXX
args_w, kwds_w = __args__.unpack()
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/pypyjit/test/test_jit_setup.py b/pypy/module/pypyjit/test/test_jit_setup.py
--- a/pypy/module/pypyjit/test/test_jit_setup.py
+++ b/pypy/module/pypyjit/test/test_jit_setup.py
@@ -9,21 +9,42 @@
# this just checks that the module is setting up things correctly, and
# the resulting code makes sense on top of CPython.
import pypyjit
- pypyjit.set_param(threshold=5, inlining=1)
- pypyjit.set_param("trace_eagerness=3,inlining=0")
+ try:
+ pypyjit.set_param(threshold=5, inlining=1)
+ pypyjit.set_param("trace_eagerness=3,inlining=0")
- def f(x, y):
- return x*y+1
+ def f(x, y):
+ return x*y+1
- assert f(6, 7) == 43
+ assert f(6, 7) == 43
- def gen(x):
- i = 0
- while i < x:
- yield i*i
- i += 1
+ def gen(x):
+ i = 0
+ while i < x:
+ yield i*i
+ i += 1
- assert list(gen(3)) == [0, 1, 4]
+ assert list(gen(3)) == [0, 1, 4]
+ finally:
+ pypyjit.set_param('default')
+
+ def test_no_jit(self):
+ import pypyjit
+ was_called = []
+ def should_not_be_called(*args, **kwds):
+ was_called.append((args, kwds))
+ try:
+ pypyjit.set_param('off')
+ pypyjit.set_compile_hook(should_not_be_called)
+ def f():
+ pass
+ for i in range(2500):
+ f()
+ assert not was_called
+ finally:
+ pypyjit.set_compile_hook(None)
+ pypyjit.set_param('default')
+
def test_interface_residual_call():
space = gettestobjspace(usemodules=['pypyjit'])
diff --git a/pypy/module/pypyjit/test_pypy_c/test_call.py b/pypy/module/pypyjit/test_pypy_c/test_call.py
--- a/pypy/module/pypyjit/test_pypy_c/test_call.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_call.py
@@ -66,13 +66,13 @@
ops = entry_bridge.ops_by_id('cond', opcode='LOAD_GLOBAL')
assert log.opnames(ops) == ["guard_value",
"getfield_gc", "guard_value",
- "getfield_gc", "guard_isnull",
+ "getfield_gc", "guard_value",
"getfield_gc", "guard_nonnull_class"]
# LOAD_GLOBAL of OFFSET but in different function partially folded
# away
# XXX could be improved
ops = entry_bridge.ops_by_id('add', opcode='LOAD_GLOBAL')
- assert log.opnames(ops) == ["guard_value", "getfield_gc", "guard_isnull"]
+ assert log.opnames(ops) == ["guard_value", "getfield_gc", "guard_value"]
#
# two LOAD_GLOBAL of f, the second is folded away
ops = entry_bridge.ops_by_id('call', opcode='LOAD_GLOBAL')
@@ -209,6 +209,26 @@
i16 = force_token()
""")
+ def test_kwargs_empty(self):
+ def main(x):
+ def g(**args):
+ return len(args) + 1
+ #
+ s = 0
+ d = {}
+ i = 0
+ while i < x:
+ s += g(**d) # ID: call
+ i += 1
+ return s
+ #
+ log = self.run(main, [1000])
+ assert log.result == 1000
+ loop, = log.loops_by_id('call')
+ ops = log.opnames(loop.ops_by_id('call'))
+ guards = [ops for ops in ops if ops.startswith('guard')]
+ assert guards == ["guard_no_overflow"]
+
def test_kwargs(self):
# this is not a very precise test, could be improved
def main(x):
@@ -216,20 +236,24 @@
return len(args)
#
s = 0
- d = {}
- for i in range(x):
+ d = {"a": 1}
+ i = 0
+ while i < x:
s += g(**d) # ID: call
d[str(i)] = i
if i % 100 == 99:
- d = {}
+ d = {"a": 1}
+ i += 1
return s
#
log = self.run(main, [1000])
- assert log.result == 49500
+ assert log.result == 50500
loop, = log.loops_by_id('call')
+ print loop.ops_by_id('call')
ops = log.opnames(loop.ops_by_id('call'))
guards = [ops for ops in ops if ops.startswith('guard')]
- assert len(guards) <= 5
+ print guards
+ assert len(guards) <= 20
def test_stararg_virtual(self):
def main(x):
@@ -277,12 +301,12 @@
i21 = force_token()
setfield_gc(p4, i20, descr=<.* .*W_AbstractSeqIterObject.inst_index .*>)
i23 = int_add_ovf(i9, 3)
- guard_no_overflow(descr=<Guard37>)
+ guard_no_overflow(descr=...)
""")
assert loop1.match_by_id('h2', """
i25 = force_token()
i27 = int_add_ovf(i23, 2)
- guard_no_overflow(descr=<Guard38>)
+ guard_no_overflow(descr=...)
""")
def test_stararg(self):
diff --git a/pypy/module/pypyjit/test_pypy_c/test_containers.py b/pypy/module/pypyjit/test_pypy_c/test_containers.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/pypyjit/test_pypy_c/test_containers.py
@@ -0,0 +1,25 @@
+
+import py, sys
+from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
+
+
+class TestDicts(BaseTestPyPyC):
+ def test_strdict(self):
+ def fn(n):
+ import sys
+ d = {}
+ class A(object):
+ pass
+ a = A()
+ a.x = 1
+ for s in sys.modules.keys() * 1000:
+ inc = a.x # ID: look
+ d[s] = d.get(s, 0) + inc
+ return sum(d.values())
+ #
+ log = self.run(fn, [1000])
+ assert log.result % 1000 == 0
+ loop, = log.loops_by_filename(self.filepath)
+ ops = loop.ops_by_id('look')
+ assert log.opnames(ops) == ['setfield_gc',
+ 'guard_not_invalidated']
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/module/sys/vm.py b/pypy/module/sys/vm.py
--- a/pypy/module/sys/vm.py
+++ b/pypy/module/sys/vm.py
@@ -57,7 +57,8 @@
raise OperationError(space.w_ValueError,
space.wrap("recursion limit must be positive"))
space.sys.recursionlimit = new_limit
- _stack_set_length_fraction(new_limit * 0.001)
+ if space.config.translation.type_system == 'lltype':
+ _stack_set_length_fraction(new_limit * 0.001)
def getrecursionlimit(space):
"""Return the last value set by setrecursionlimit().
diff --git a/pypy/module/test_lib_pypy/ctypes_tests/test_commethods.py b/pypy/module/test_lib_pypy/ctypes_tests/test_commethods.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/test_lib_pypy/ctypes_tests/test_commethods.py
@@ -0,0 +1,82 @@
+# unittest for SOME ctypes com function calls.
+# Can't resist from implementing some kind of mini-comtypes
+# theller ;-)
+
+import py
+import sys
+if sys.platform != "win32":
+ py.test.skip('windows only test')
+
+import ctypes, new, unittest
+from ctypes.wintypes import HRESULT
+from _ctypes import COMError
+
+oleaut32 = ctypes.OleDLL("oleaut32")
+
+class UnboundMethod(object):
+ def __init__(self, func, index, name):
+ self.func = func
+ self.index = index
+ self.name = name
+ self.__doc__ = func.__doc__
+
+ def __repr__(self):
+ return "<Unbound COM method index %d: %s at %x>" % (self.index, self.name, id(self))
+
+ def __get__(self, instance, owner):
+ if instance is None:
+ return self
+ return new.instancemethod(self.func, instance, owner)
+
+def commethod(index, restype, *argtypes):
+ """A decorator that generates COM methods. The decorated function
+ itself is not used except for it's name."""
+ def make_commethod(func):
+ comfunc = ctypes.WINFUNCTYPE(restype, *argtypes)(index, func.__name__)
+ comfunc.__name__ = func.__name__
+ comfunc.__doc__ = func.__doc__
+ return UnboundMethod(comfunc, index, func.__name__)
+ return make_commethod
+
+class ICreateTypeLib2(ctypes.c_void_p):
+
+ @commethod(1, ctypes.c_long)
+ def AddRef(self):
+ pass
+
+ @commethod(2, ctypes.c_long)
+ def Release(self):
+ pass
+
+ @commethod(4, HRESULT, ctypes.c_wchar_p)
+ def SetName(self):
+ """Set the name of the library."""
+
+ @commethod(12, HRESULT)
+ def SaveAllChanges(self):
+ pass
+
+
+CreateTypeLib2 = oleaut32.CreateTypeLib2
+CreateTypeLib2.argtypes = (ctypes.c_int, ctypes.c_wchar_p, ctypes.POINTER(ICreateTypeLib2))
+
+################################################################
+
+def test_basic_comtypes():
+ punk = ICreateTypeLib2()
+ hr = CreateTypeLib2(0, "foobar.tlb", punk)
+ assert hr == 0
+
+ assert 2 == punk.AddRef()
+ assert 3 == punk.AddRef()
+ assert 4 == punk.AddRef()
+
+ punk.SetName("TypeLib_ByPYPY")
+ py.test.raises(COMError, lambda: punk.SetName(None))
+
+ # This would save the typelib to disk.
+ ## punk.SaveAllChanges()
+
+ assert 3 == punk.Release()
+ assert 2 == punk.Release()
+ assert 1 == punk.Release()
diff --git a/pypy/module/test_lib_pypy/test_pwd.py b/pypy/module/test_lib_pypy/test_pwd.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/test_lib_pypy/test_pwd.py
@@ -0,0 +1,12 @@
+from pypy.conftest import gettestobjspace
+
+class AppTestPwd:
+ def setup_class(cls):
+ cls.space = gettestobjspace(usemodules=('_ffi', '_rawffi'))
+ cls.space.appexec((), "(): import pwd")
+
+ def test_getpwuid(self):
+ import os, pwd
+ passwd_info = pwd.getpwuid(os.getuid())
+ assert type(passwd_info).__name__ == 'struct_passwd'
+ assert repr(passwd_info).startswith("pwd.struct_passwd(pw_name=")
diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py
--- a/pypy/objspace/descroperation.py
+++ b/pypy/objspace/descroperation.py
@@ -416,7 +416,7 @@
# obscure circumstances.
return default_identity_hash(space, w_obj)
if space.is_w(w_hash, space.w_None):
- typename = space.type(w_obj).getname(space, '?')
+ typename = space.type(w_obj).getname(space)
raise operationerrfmt(space.w_TypeError,
"'%s' objects are unhashable", typename)
w_result = space.get_and_call_function(w_hash, w_obj)
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/bytearrayobject.py b/pypy/objspace/std/bytearrayobject.py
--- a/pypy/objspace/std/bytearrayobject.py
+++ b/pypy/objspace/std/bytearrayobject.py
@@ -374,7 +374,7 @@
raise operationerrfmt(
space.w_TypeError,
"sequence item %d: expected string, %s "
- "found", i, space.type(w_s).getname(space, '?'))
+ "found", i, space.type(w_s).getname(space))
if data and i != 0:
newdata.extend(data)
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
@@ -4,8 +4,9 @@
speed up global lookups a lot."""
from pypy.objspace.std.dictmultiobject import IteratorImplementation
-from pypy.objspace.std.dictmultiobject import W_DictMultiObject, _is_sane_hash
-from pypy.rlib import jit
+from pypy.objspace.std.dictmultiobject import DictStrategy, _never_equal_to_string
+from pypy.objspace.std.dictmultiobject import ObjectDictStrategy
+from pypy.rlib import jit, rerased
class ModuleCell(object):
def __init__(self, w_value=None):
@@ -19,49 +20,59 @@
def __repr__(self):
return "<ModuleCell: %s>" % (self.w_value, )
-class ModuleDictImplementation(W_DictMultiObject):
+class ModuleDictStrategy(DictStrategy):
+
+ erase, unerase = rerased.new_erasing_pair("modulecell")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
+
def __init__(self, space):
self.space = space
- self.content = {}
- def getcell(self, key, makenew):
+ def get_empty_storage(self):
+ return self.erase({})
+
+ def getcell(self, w_dict, key, makenew):
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
- self = jit.hint(self, promote=True)
- return self._getcell_makenew(key)
- return self.content.get(key, None)
+ 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
- def _getcell_makenew(self, key):
- return self.content.setdefault(key, ModuleCell())
+ @jit.elidable
+ def _getcell_makenew(self, w_dict, key):
+ return self.unerase(w_dict.dstorage).setdefault(key, ModuleCell())
- def impl_setitem(self, w_key, w_value):
+ def setitem(self, w_dict, w_key, w_value):
space = self.space
if space.is_w(space.type(w_key), space.w_str):
- self.impl_setitem_str(self.space.str_w(w_key), w_value)
+ self.setitem_str(w_dict, self.space.str_w(w_key), w_value)
else:
- self._as_rdict().impl_fallback_setitem(w_key, w_value)
+ self.switch_to_object_strategy(w_dict)
+ w_dict.setitem(w_key, w_value)
- def impl_setitem_str(self, name, w_value):
- self.getcell(name, True).w_value = w_value
+ def setitem_str(self, w_dict, key, w_value):
+ self.getcell(w_dict, key, True).w_value = w_value
- def impl_setdefault(self, w_key, w_default):
+ def setdefault(self, w_dict, w_key, w_default):
space = self.space
if space.is_w(space.type(w_key), space.w_str):
- cell = self.getcell(space.str_w(w_key), True)
+ cell = self.getcell(w_dict, space.str_w(w_key), True)
if cell.w_value is None:
cell.w_value = w_default
return cell.w_value
else:
- return self._as_rdict().impl_fallback_setdefault(w_key, w_default)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.setdefault(w_key, w_default)
- def impl_delitem(self, w_key):
+ def delitem(self, w_dict, w_key):
space = self.space
w_key_type = space.type(w_key)
if space.is_w(w_key_type, space.w_str):
key = space.str_w(w_key)
- cell = self.getcell(key, False)
+ cell = self.getcell(w_dict, key, False)
if cell is None or cell.w_value is None:
raise KeyError
# note that we don't remove the cell from self.content, to make
@@ -69,75 +80,91 @@
# maps to the same cell later (even if this cell no longer
# represents a key)
cell.invalidate()
- elif _is_sane_hash(space, w_key_type):
+ elif _never_equal_to_string(space, w_key_type):
raise KeyError
else:
- self._as_rdict().impl_fallback_delitem(w_key)
-
- def impl_length(self):
+ self.switch_to_object_strategy(w_dict)
+ w_dict.delitem(w_key)
+
+ def length(self, w_dict):
# inefficient, but do we care?
res = 0
- for cell in self.content.itervalues():
+ for cell in self.unerase(w_dict.dstorage).itervalues():
if cell.w_value is not None:
res += 1
return res
- def impl_getitem(self, w_lookup):
+ def getitem(self, w_dict, w_key):
space = self.space
- w_lookup_type = space.type(w_lookup)
+ w_lookup_type = space.type(w_key)
if space.is_w(w_lookup_type, space.w_str):
- return self.impl_getitem_str(space.str_w(w_lookup))
+ return self.getitem_str(w_dict, space.str_w(w_key))
- elif _is_sane_hash(space, w_lookup_type):
+ elif _never_equal_to_string(space, w_lookup_type):
return None
else:
- return self._as_rdict().impl_fallback_getitem(w_lookup)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.getitem(w_key)
- def impl_getitem_str(self, lookup):
- res = self.getcell(lookup, False)
+ def getitem_str(self, w_dict, key):
+ res = self.getcell(w_dict, key, False)
if res is None:
return None
# note that even if the res.w_value is None, the next line is fine
return res.w_value
- def impl_iter(self):
- return ModuleDictIteratorImplementation(self.space, self)
+ def iter(self, w_dict):
+ return ModuleDictIteratorImplementation(self.space, self, w_dict)
- def impl_keys(self):
+ def keys(self, w_dict):
space = self.space
- return [space.wrap(key) for key, cell in self.content.iteritems()
+ iterator = self.unerase(w_dict.dstorage).iteritems
+ return [space.wrap(key) for key, cell in iterator()
if cell.w_value is not None]
- def impl_values(self):
- return [cell.w_value for cell in self.content.itervalues()
+ def values(self, w_dict):
+ iterator = self.unerase(w_dict.dstorage).itervalues
+ return [cell.w_value for cell in iterator()
if cell.w_value is not None]
- def impl_items(self):
+ def items(self, w_dict):
space = self.space
+ iterator = self.unerase(w_dict.dstorage).iteritems
return [space.newtuple([space.wrap(key), cell.w_value])
- for (key, cell) in self.content.iteritems()
+ for (key, cell) in iterator()
if cell.w_value is not None]
- def impl_clear(self):
- for k, cell in self.content.iteritems():
+ def clear(self, w_dict):
+ iterator = self.unerase(w_dict.dstorage).iteritems
+ for k, cell in iterator():
cell.invalidate()
- def _as_rdict(self):
- r_dict_content = self.initialize_as_rdict()
- for k, cell in self.content.iteritems():
+ def popitem(self, w_dict):
+ # This is O(n) if called repeatadly, you probably shouldn't be on a
+ # Module's dict though
+ for k, cell in self.unerase(w_dict.dstorage).iteritems():
if cell.w_value is not None:
- r_dict_content[self.space.wrap(k)] = cell.w_value
- cell.invalidate()
- self._clear_fields()
- return self
+ w_value = cell.w_value
+ cell.invalidate()
+ return self.space.wrap(k), w_value
+ else:
+ raise KeyError
- def _clear_fields(self):
- self.content = None
+ def switch_to_object_strategy(self, w_dict):
+ d = self.unerase(w_dict.dstorage)
+ strategy = self.space.fromcache(ObjectDictStrategy)
+ d_new = strategy.unerase(strategy.get_empty_storage())
+ for key, cell in d.iteritems():
+ if cell.w_value is not None:
+ d_new[self.space.wrap(key)] = cell.w_value
+ w_dict.strategy = strategy
+ w_dict.dstorage = strategy.erase(d_new)
class ModuleDictIteratorImplementation(IteratorImplementation):
- def __init__(self, space, dictimplementation):
+ def __init__(self, space, strategy, dictimplementation):
IteratorImplementation.__init__(self, space, dictimplementation)
- self.iterator = dictimplementation.content.iteritems()
+ dict_w = strategy.unerase(dictimplementation.dstorage)
+ self.iterator = dict_w.iteritems()
def next_entry(self):
for key, cell in self.iterator:
diff --git a/pypy/objspace/std/dictmultiobject.py b/pypy/objspace/std/dictmultiobject.py
--- a/pypy/objspace/std/dictmultiobject.py
+++ b/pypy/objspace/std/dictmultiobject.py
@@ -5,15 +5,16 @@
from pypy.interpreter import gateway
from pypy.interpreter.argument import Signature
from pypy.interpreter.error import OperationError, operationerrfmt
-from pypy.module.__builtin__.__init__ import BUILTIN_TO_INDEX, OPTIMIZED_BUILTINS
-from pypy.rlib.objectmodel import r_dict, we_are_translated
+from pypy.rlib.objectmodel import r_dict, we_are_translated, specialize
from pypy.rlib.debug import mark_dict_non_null
+from pypy.rlib import rerased
+
def _is_str(space, w_key):
return space.is_w(space.type(w_key), space.w_str)
-def _is_sane_hash(space, w_lookup_type):
+def _never_equal_to_string(space, w_lookup_type):
""" Handles the case of a non string key lookup.
Types that have a sane hash/eq function should allow us to return True
directly to signal that the key is not in the dict in any case.
@@ -29,49 +30,38 @@
class W_DictMultiObject(W_Object):
from pypy.objspace.std.dicttype import dict_typedef as typedef
- r_dict_content = None
-
@staticmethod
def allocate_and_init_instance(space, w_type=None, module=False,
instance=False, classofinstance=None,
strdict=False):
+
if space.config.objspace.std.withcelldict and module:
- from pypy.objspace.std.celldict import ModuleDictImplementation
+ from pypy.objspace.std.celldict import ModuleDictStrategy
assert w_type is None
- return ModuleDictImplementation(space)
- elif space.config.objspace.opcodes.CALL_LIKELY_BUILTIN and module:
- assert w_type is None
- return WaryDictImplementation(space)
- elif space.config.objspace.std.withdictmeasurement:
- assert w_type is None
- return MeasuringDictImplementation(space)
+ strategy = space.fromcache(ModuleDictStrategy)
+
elif instance or strdict or module:
assert w_type is None
- return StrDictImplementation(space)
+ strategy = space.fromcache(StringDictStrategy)
+
else:
- if w_type is None:
- w_type = space.w_dict
- w_self = space.allocate_instance(W_DictMultiObject, w_type)
- W_DictMultiObject.__init__(w_self, space)
- return w_self
+ strategy = space.fromcache(EmptyDictStrategy)
- def __init__(self, space):
+ if w_type is None:
+ w_type = space.w_dict
+ storage = strategy.get_empty_storage()
+ w_self = space.allocate_instance(W_DictMultiObject, w_type)
+ W_DictMultiObject.__init__(w_self, space, strategy, storage)
+ return w_self
+
+ def __init__(self, space, strategy, storage):
self.space = space
-
- def initialize_as_rdict(self):
- assert self.r_dict_content is None
- self.r_dict_content = r_dict(self.space.eq_w, self.space.hash_w,
- force_non_null=True)
- return self.r_dict_content
-
-
- def initialize_content(w_self, list_pairs_w):
- for w_k, w_v in list_pairs_w:
- w_self.setitem(w_k, w_v)
+ self.strategy = strategy
+ self.dstorage = storage
def __repr__(w_self):
""" representation for debugging purposes """
- return "%s()" % (w_self.__class__.__name__, )
+ return "%s(%s)" % (w_self.__class__.__name__, w_self.strategy)
def unwrap(w_dict, space):
result = {}
@@ -90,51 +80,38 @@
else:
return None
- # _________________________________________________________________
- # implementation methods
- def impl_getitem(self, w_key):
- #return w_value or None
- # in case the key is unhashable, try to hash it
- self.space.hash(w_key)
- # return None anyway
- return None
+ def initialize_content(w_self, list_pairs_w):
+ for w_k, w_v in list_pairs_w:
+ w_self.setitem(w_k, w_v)
- def impl_getitem_str(self, key):
- #return w_value or None
- return None
+def _add_indirections():
+ dict_methods = "setitem setitem_str getitem \
+ getitem_str delitem length \
+ clear keys values \
+ items iter setdefault \
+ popitem".split()
- def impl_setdefault(self, w_key, w_default):
- # here the dict is always empty
- self._as_rdict().impl_fallback_setitem(w_key, w_default)
- return w_default
+ def make_method(method):
+ def f(self, *args):
+ return getattr(self.strategy, method)(self, *args)
+ f.func_name = method
+ return f
- def impl_setitem(self, w_key, w_value):
- self._as_rdict().impl_fallback_setitem(w_key, w_value)
+ for method in dict_methods:
+ setattr(W_DictMultiObject, method, make_method(method))
- def impl_setitem_str(self, key, w_value):
- self._as_rdict().impl_fallback_setitem_str(key, w_value)
+_add_indirections()
- def impl_delitem(self, w_key):
- # in case the key is unhashable, try to hash it
- self.space.hash(w_key)
- raise KeyError
+class DictStrategy(object):
- def impl_length(self):
- return 0
+ def __init__(self, space):
+ self.space = space
- def impl_iter(self):
- # XXX I guess it's not important to be fast in this case?
- return self._as_rdict().impl_fallback_iter()
+ def get_empty_storage(self):
+ raise NotImplementedError
- def impl_clear(self):
- self.r_dict_content = None
-
- def _as_rdict(self):
- r_dict_content = self.initialize_as_rdict()
- return self
-
- def impl_keys(self):
- iterator = self.impl_iter()
+ def keys(self, w_dict):
+ iterator = self.iter(w_dict)
result = []
while 1:
w_key, w_value = iterator.next()
@@ -142,8 +119,9 @@
result.append(w_key)
else:
return result
- def impl_values(self):
- iterator = self.impl_iter()
+
+ def values(self, w_dict):
+ iterator = self.iter(w_dict)
result = []
while 1:
w_key, w_value = iterator.next()
@@ -151,8 +129,9 @@
result.append(w_value)
else:
return result
- def impl_items(self):
- iterator = self.impl_iter()
+
+ def items(self, w_dict):
+ iterator = self.iter(w_dict)
result = []
while 1:
w_key, w_value = iterator.next()
@@ -161,106 +140,90 @@
else:
return result
- # the following method only makes sense when the option to use the
- # CALL_LIKELY_BUILTIN opcode is set. Otherwise it won't even be seen
- # by the annotator
- def impl_get_builtin_indexed(self, i):
- key = OPTIMIZED_BUILTINS[i]
- return self.impl_getitem_str(key)
+ def clear(self, w_dict):
+ strategy = self.space.fromcache(EmptyDictStrategy)
+ storage = strategy.get_empty_storage()
+ w_dict.strategy = strategy
+ w_dict.dstorage = storage
- def impl_popitem(self):
- # default implementation
- space = self.space
- iterator = self.impl_iter()
- w_key, w_value = iterator.next()
- if w_key is None:
- raise KeyError
- self.impl_delitem(w_key)
- return w_key, w_value
- # _________________________________________________________________
- # fallback implementation methods
+class EmptyDictStrategy(DictStrategy):
- def impl_fallback_setdefault(self, w_key, w_default):
- return self.r_dict_content.setdefault(w_key, w_default)
+ erase, unerase = rerased.new_erasing_pair("empty")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
- def impl_fallback_setitem(self, w_key, w_value):
- self.r_dict_content[w_key] = w_value
+ def get_empty_storage(self):
+ return self.erase(None)
- def impl_fallback_setitem_str(self, key, w_value):
- return self.impl_fallback_setitem(self.space.wrap(key), w_value)
+ def switch_to_correct_strategy(self, w_dict, w_key):
+ #XXX implement other strategies later
+ if type(w_key) is self.space.StringObjectCls:
+ self.switch_to_string_strategy(w_dict)
+ elif self.space.is_w(self.space.type(w_key), self.space.w_int):
+ self.switch_to_int_strategy(w_dict)
+ else:
+ self.switch_to_object_strategy(w_dict)
- def impl_fallback_delitem(self, w_key):
- del self.r_dict_content[w_key]
+ def switch_to_string_strategy(self, w_dict):
+ strategy = self.space.fromcache(StringDictStrategy)
+ storage = strategy.get_empty_storage()
+ w_dict.strategy = strategy
+ w_dict.dstorage = storage
- def impl_fallback_length(self):
- return len(self.r_dict_content)
+ def switch_to_int_strategy(self, w_dict):
+ strategy = self.space.fromcache(IntDictStrategy)
+ storage = strategy.get_empty_storage()
+ w_dict.strategy = strategy
+ w_dict.dstorage = storage
- def impl_fallback_getitem(self, w_key):
- return self.r_dict_content.get(w_key, None)
+ def switch_to_object_strategy(self, w_dict):
+ strategy = self.space.fromcache(ObjectDictStrategy)
+ storage = strategy.get_empty_storage()
+ w_dict.strategy = strategy
+ w_dict.dstorage = storage
- def impl_fallback_getitem_str(self, key):
- return self.r_dict_content.get(self.space.wrap(key), None)
+ def getitem(self, w_dict, w_key):
+ #return w_value or None
+ # in case the key is unhashable, try to hash it
+ self.space.hash(w_key)
+ # return None anyway
+ return None
- def impl_fallback_iter(self):
- return RDictIteratorImplementation(self.space, self)
+ def getitem_str(self, w_dict, key):
+ #return w_value or None
+ return None
- def impl_fallback_keys(self):
- return self.r_dict_content.keys()
- def impl_fallback_values(self):
- return self.r_dict_content.values()
- def impl_fallback_items(self):
- return [self.space.newtuple([w_key, w_val])
- for w_key, w_val in self.r_dict_content.iteritems()]
+ def setdefault(self, w_dict, w_key, w_default):
+ # here the dict is always empty
+ self.switch_to_correct_strategy(w_dict, w_key)
+ w_dict.setitem(w_key, w_default)
+ return w_default
- def impl_fallback_clear(self):
- self.r_dict_content.clear()
+ def setitem(self, w_dict, w_key, w_value):
+ self.switch_to_correct_strategy(w_dict, w_key)
+ w_dict.setitem(w_key, w_value)
- def impl_fallback_get_builtin_indexed(self, i):
- key = OPTIMIZED_BUILTINS[i]
- return self.impl_fallback_getitem_str(key)
+ def setitem_str(self, w_dict, key, w_value):
+ self.switch_to_string_strategy(w_dict)
+ w_dict.setitem_str(key, w_value)
- def impl_fallback_popitem(self):
- return self.r_dict_content.popitem()
+ def delitem(self, w_dict, w_key):
+ # in case the key is unhashable, try to hash it
+ self.space.hash(w_key)
+ raise KeyError
+ def length(self, w_dict):
+ return 0
-implementation_methods = [
- ("getitem", 1),
- ("getitem_str", 1),
- ("length", 0),
- ("setitem_str", 2),
- ("setitem", 2),
- ("setdefault", 2),
- ("delitem", 1),
- ("iter", 0),
- ("items", 0),
- ("values", 0),
- ("keys", 0),
- ("clear", 0),
- ("get_builtin_indexed", 1),
- ("popitem", 0),
-]
+ def iter(self, w_dict):
+ return EmptyIteratorImplementation(self.space, w_dict)
+ def clear(self, w_dict):
+ return
-def _make_method(name, implname, fallback, numargs):
- args = ", ".join(["a" + str(i) for i in range(numargs)])
- code = """def %s(self, %s):
- if self.r_dict_content is not None:
- return self.%s(%s)
- return self.%s(%s)""" % (name, args, fallback, args, implname, args)
- d = {}
- exec py.code.Source(code).compile() in d
- implementation_method = d[name]
- implementation_method.func_defaults = getattr(W_DictMultiObject, implname).func_defaults
- return implementation_method
-
-def _install_methods():
- for name, numargs in implementation_methods:
- implname = "impl_" + name
- fallbackname = "impl_fallback_" + name
- func = _make_method(name, implname, fallbackname, numargs)
- setattr(W_DictMultiObject, name, func)
-_install_methods()
+ def popitem(self, w_dict):
+ raise KeyError
registerimplementation(W_DictMultiObject)
@@ -302,322 +265,255 @@
return self.len - self.pos
return 0
+class EmptyIteratorImplementation(IteratorImplementation):
+ def next(self):
+ return (None, None)
+
# concrete subclasses of the above
-class StrDictImplementation(W_DictMultiObject):
- def __init__(self, space):
- self.space = space
- self.content = {}
- mark_dict_non_null(self.content)
+class AbstractTypedStrategy(object):
+ _mixin_ = True
- def impl_setitem(self, w_key, w_value):
+ @staticmethod
+ def erase(storage):
+ raise NotImplementedError("abstract base class")
+
+ @staticmethod
+ def unerase(obj):
+ raise NotImplementedError("abstract base class")
+
+ def wrap(self, unwrapped):
+ raise NotImplementedError
+
+ def unwrap(self, wrapped):
+ raise NotImplementedError
+
+ def is_correct_type(self, w_obj):
+ raise NotImplementedError("abstract base class")
+
+ def get_empty_storage(self):
+ raise NotImplementedError("abstract base class")
+
+ def _never_equal_to(self, w_lookup_type):
+ raise NotImplementedError("abstract base class")
+
+ def setitem(self, w_dict, w_key, w_value):
space = self.space
- if space.is_w(space.type(w_key), space.w_str):
- self.impl_setitem_str(self.space.str_w(w_key), w_value)
+ if self.is_correct_type(w_key):
+ self.unerase(w_dict.dstorage)[self.unwrap(w_key)] = w_value
+ return
else:
- self._as_rdict().impl_fallback_setitem(w_key, w_value)
+ self.switch_to_object_strategy(w_dict)
+ w_dict.setitem(w_key, w_value)
- def impl_setitem_str(self, key, w_value):
- assert key is not None
- self.content[key] = w_value
+ def setitem_str(self, w_dict, key, w_value):
+ self.switch_to_object_strategy(w_dict)
+ w_dict.setitem(self.space.wrap(key), w_value)
- def impl_setdefault(self, w_key, w_default):
+ def setdefault(self, w_dict, w_key, w_default):
space = self.space
- if space.is_w(space.type(w_key), space.w_str):
- return self.content.setdefault(space.str_w(w_key), w_default)
+ if self.is_correct_type(w_key):
+ return self.unerase(w_dict.dstorage).setdefault(self.unwrap(w_key), w_default)
else:
- return self._as_rdict().impl_fallback_setdefault(w_key, w_default)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.setdefault(w_key, w_default)
-
- def impl_delitem(self, w_key):
+ def delitem(self, w_dict, w_key):
space = self.space
w_key_type = space.type(w_key)
- if space.is_w(w_key_type, space.w_str):
- del self.content[space.str_w(w_key)]
+ if self.is_correct_type(w_key):
+ del self.unerase(w_dict.dstorage)[self.unwrap(w_key)]
return
- elif _is_sane_hash(space, w_key_type):
- raise KeyError
else:
- self._as_rdict().impl_fallback_delitem(w_key)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.delitem(w_key)
- def impl_length(self):
- return len(self.content)
+ def length(self, w_dict):
+ return len(self.unerase(w_dict.dstorage))
- def impl_getitem_str(self, key):
+ def getitem_str(self, w_dict, key):
+ return self.getitem(w_dict, self.space.wrap(key))
+
+ def getitem(self, w_dict, w_key):
+ space = self.space
+
+ if self.is_correct_type(w_key):
+ return self.unerase(w_dict.dstorage).get(self.unwrap(w_key), None)
+ elif self._never_equal_to(space.type(w_key)):
+ return None
+ else:
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.getitem(w_key)
+
+ def keys(self, w_dict):
+ return [self.wrap(key) for key in self.unerase(w_dict.dstorage).iterkeys()]
+
+ def values(self, w_dict):
+ return self.unerase(w_dict.dstorage).values()
+
+ def items(self, w_dict):
+ space = self.space
+ dict_w = self.unerase(w_dict.dstorage)
+ return [space.newtuple([self.wrap(key), w_value])
+ for (key, w_value) in dict_w.iteritems()]
+
+ def popitem(self, w_dict):
+ key, value = self.unerase(w_dict.dstorage).popitem()
+ return (self.wrap(key), value)
+
+ def clear(self, w_dict):
+ self.unerase(w_dict.dstorage).clear()
+
+ def switch_to_object_strategy(self, w_dict):
+ d = self.unerase(w_dict.dstorage)
+ strategy = self.space.fromcache(ObjectDictStrategy)
+ d_new = strategy.unerase(strategy.get_empty_storage())
+ for key, value in d.iteritems():
+ d_new[self.wrap(key)] = value
+ w_dict.strategy = strategy
+ w_dict.dstorage = strategy.erase(d_new)
+
+class ObjectDictStrategy(AbstractTypedStrategy, DictStrategy):
+
+ erase, unerase = rerased.new_erasing_pair("object")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
+
+ def wrap(self, unwrapped):
+ return unwrapped
+
+ def unwrap(self, wrapped):
+ return wrapped
+
+ def is_correct_type(self, w_obj):
+ return True
+
+ def get_empty_storage(self):
+ new_dict = r_dict(self.space.eq_w, self.space.hash_w,
+ force_non_null=True)
+ return self.erase(new_dict)
+
+ def _never_equal_to(self, w_lookup_type):
+ return False
+
+ def iter(self, w_dict):
+ return ObjectIteratorImplementation(self.space, self, w_dict)
+
+ def keys(self, w_dict):
+ return self.unerase(w_dict.dstorage).keys()
+
+class StringDictStrategy(AbstractTypedStrategy, DictStrategy):
+
+ erase, unerase = rerased.new_erasing_pair("string")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
+
+ def wrap(self, unwrapped):
+ return self.space.wrap(unwrapped)
+
+ def unwrap(self, wrapped):
+ return self.space.str_w(wrapped)
+
+ def is_correct_type(self, w_obj):
+ space = self.space
+ return space.is_w(space.type(w_obj), space.w_str)
+
+ def get_empty_storage(self):
+ res = {}
+ mark_dict_non_null(res)
+ return self.erase(res)
+
+ def _never_equal_to(self, w_lookup_type):
+ return _never_equal_to_string(self.space, w_lookup_type)
+
+ def setitem_str(self, w_dict, key, w_value):
assert key is not None
- return self.content.get(key, None)
+ self.unerase(w_dict.dstorage)[key] = w_value
- def impl_getitem(self, w_key):
+ def getitem(self, w_dict, w_key):
space = self.space
# -- This is called extremely often. Hack for performance --
if type(w_key) is space.StringObjectCls:
- return self.impl_getitem_str(w_key.unwrap(space))
+ return self.getitem_str(w_dict, w_key.unwrap(space))
# -- End of performance hack --
- w_lookup_type = space.type(w_key)
- if space.is_w(w_lookup_type, space.w_str):
- return self.impl_getitem_str(space.str_w(w_key))
- elif _is_sane_hash(space, w_lookup_type):
- return None
- else:
- return self._as_rdict().impl_fallback_getitem(w_key)
+ return AbstractTypedStrategy.getitem(self, w_dict, w_key)
- def impl_iter(self):
- return StrIteratorImplementation(self.space, self)
+ def getitem_str(self, w_dict, key):
+ assert key is not None
+ return self.unerase(w_dict.dstorage).get(key, None)
- def impl_keys(self):
- space = self.space
- return [space.wrap(key) for key in self.content.iterkeys()]
+ def iter(self, w_dict):
+ return StrIteratorImplementation(self.space, self, w_dict)
- def impl_values(self):
- return self.content.values()
-
- def impl_items(self):
- space = self.space
- return [space.newtuple([space.wrap(key), w_value])
- for (key, w_value) in self.content.iteritems()]
-
- def impl_clear(self):
- self.content.clear()
-
-
- def _as_rdict(self):
- r_dict_content = self.initialize_as_rdict()
- for k, w_v in self.content.items():
- r_dict_content[self.space.wrap(k)] = w_v
- self._clear_fields()
- return self
-
- def _clear_fields(self):
- self.content = None
class StrIteratorImplementation(IteratorImplementation):
- def __init__(self, space, dictimplementation):
+ def __init__(self, space, strategy, dictimplementation):
IteratorImplementation.__init__(self, space, dictimplementation)
- self.iterator = dictimplementation.content.iteritems()
+ self.iterator = strategy.unerase(dictimplementation.dstorage).iteritems()
def next_entry(self):
# note that this 'for' loop only runs once, at most
- for str, w_value in self.iterator:
- return self.space.wrap(str), w_value
+ for key, w_value in self.iterator:
+ return self.space.wrap(key), w_value
else:
return None, None
-class WaryDictImplementation(StrDictImplementation):
- def __init__(self, space):
- StrDictImplementation.__init__(self, space)
- self.shadowed = [None] * len(BUILTIN_TO_INDEX)
+class IntDictStrategy(AbstractTypedStrategy, DictStrategy):
+ erase, unerase = rerased.new_erasing_pair("int")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
- def impl_setitem_str(self, key, w_value):
- i = BUILTIN_TO_INDEX.get(key, -1)
- if i != -1:
- self.shadowed[i] = w_value
- self.content[key] = w_value
+ def wrap(self, unwrapped):
+ return self.space.wrap(unwrapped)
- def impl_delitem(self, w_key):
+ def unwrap(self, wrapped):
+ return self.space.int_w(wrapped)
+
+ def get_empty_storage(self):
+ return self.erase({})
+
+ def is_correct_type(self, w_obj):
space = self.space
- w_key_type = space.type(w_key)
- if space.is_w(w_key_type, space.w_str):
- key = space.str_w(w_key)
- del self.content[key]
- i = BUILTIN_TO_INDEX.get(key, -1)
- if i != -1:
- self.shadowed[i] = None
- elif _is_sane_hash(space, w_key_type):
- raise KeyError
- else:
- self._as_rdict().impl_fallback_delitem(w_key)
+ return space.is_w(space.type(w_obj), space.w_int)
- def impl_get_builtin_indexed(self, i):
- return self.shadowed[i]
+ def _never_equal_to(self, w_lookup_type):
+ space = self.space
+ # XXX there are many more types
+ return (space.is_w(w_lookup_type, space.w_NoneType) or
+ space.is_w(w_lookup_type, space.w_str) or
+ space.is_w(w_lookup_type, space.w_unicode)
+ )
+ def iter(self, w_dict):
+ return IntIteratorImplementation(self.space, self, w_dict)
-class RDictIteratorImplementation(IteratorImplementation):
- def __init__(self, space, dictimplementation):
+class IntIteratorImplementation(IteratorImplementation):
+ def __init__(self, space, strategy, dictimplementation):
IteratorImplementation.__init__(self, space, dictimplementation)
- self.iterator = dictimplementation.r_dict_content.iteritems()
+ self.iterator = strategy.unerase(dictimplementation.dstorage).iteritems()
def next_entry(self):
# note that this 'for' loop only runs once, at most
- for item in self.iterator:
- return item
+ for key, w_value in self.iterator:
+ return self.space.wrap(key), w_value
else:
return None, None
+class ObjectIteratorImplementation(IteratorImplementation):
+ def __init__(self, space, strategy, dictimplementation):
+ IteratorImplementation.__init__(self, space, dictimplementation)
+ self.iterator = strategy.unerase(dictimplementation.dstorage).iteritems()
-# XXX fix this thing
-import time
-
-class DictInfo(object):
- _dict_infos = []
- def __init__(self):
- self.id = len(self._dict_infos)
-
- self.setitem_strs = 0; self.setitems = 0; self.delitems = 0
- self.lengths = 0; self.gets = 0
- self.iteritems = 0; self.iterkeys = 0; self.itervalues = 0
- self.keys = 0; self.values = 0; self.items = 0
-
- self.maxcontents = 0
-
- self.reads = 0
- self.hits = self.misses = 0
- self.writes = 0
- self.iterations = 0
- self.listings = 0
-
- self.seen_non_string_in_write = 0
- self.seen_non_string_in_read_first = 0
- self.size_on_non_string_seen_in_read = -1
- self.size_on_non_string_seen_in_write = -1
-
- self.createtime = time.time()
- self.lifetime = -1.0
-
- if not we_are_translated():
- # very probable stack from here:
- # 0 - us
- # 1 - MeasuringDictImplementation.__init__
- # 2 - W_DictMultiObject.__init__
- # 3 - space.newdict
- # 4 - newdict's caller. let's look at that
- try:
- frame = sys._getframe(4)
- except ValueError:
- pass # might be at import time
- else:
- self.sig = '(%s:%s)%s'%(frame.f_code.co_filename, frame.f_lineno, frame.f_code.co_name)
-
- self._dict_infos.append(self)
- def __repr__(self):
- args = []
- for k in sorted(self.__dict__):
- v = self.__dict__[k]
- if v != 0:
- args.append('%s=%r'%(k, v))
- return '<DictInfo %s>'%(', '.join(args),)
-
-class OnTheWayOut:
- def __init__(self, info):
- self.info = info
- def __del__(self):
- self.info.lifetime = time.time() - self.info.createtime
-
-class MeasuringDictImplementation(W_DictMultiObject):
- def __init__(self, space):
- self.space = space
- self.content = r_dict(space.eq_w, space.hash_w)
- self.info = DictInfo()
- self.thing_with_del = OnTheWayOut(self.info)
-
- def __repr__(self):
- return "%s<%s>" % (self.__class__.__name__, self.content)
-
- def _is_str(self, w_key):
- space = self.space
- return space.is_true(space.isinstance(w_key, space.w_str))
- def _read(self, w_key):
- self.info.reads += 1
- if not self.info.seen_non_string_in_write \
- and not self.info.seen_non_string_in_read_first \
- and not self._is_str(w_key):
- self.info.seen_non_string_in_read_first = True
- self.info.size_on_non_string_seen_in_read = len(self.content)
- hit = w_key in self.content
- if hit:
- self.info.hits += 1
+ def next_entry(self):
+ # note that this 'for' loop only runs once, at most
+ for w_key, w_value in self.iterator:
+ return w_key, w_value
else:
- self.info.misses += 1
-
- def impl_setitem(self, w_key, w_value):
- if not self.info.seen_non_string_in_write and not self._is_str(w_key):
- self.info.seen_non_string_in_write = True
- self.info.size_on_non_string_seen_in_write = len(self.content)
- self.info.setitems += 1
- self.info.writes += 1
- self.content[w_key] = w_value
- self.info.maxcontents = max(self.info.maxcontents, len(self.content))
- def impl_setitem_str(self, key, w_value):
- self.info.setitem_strs += 1
- self.impl_setitem(self.space.wrap(key), w_value)
- def impl_delitem(self, w_key):
- if not self.info.seen_non_string_in_write \
- and not self.info.seen_non_string_in_read_first \
- and not self._is_str(w_key):
- self.info.seen_non_string_in_read_first = True
- self.info.size_on_non_string_seen_in_read = len(self.content)
- self.info.delitems += 1
- self.info.writes += 1
- del self.content[w_key]
-
- def impl_length(self):
- self.info.lengths += 1
- return len(self.content)
- def impl_getitem_str(self, key):
- return self.impl_getitem(self.space.wrap(key))
- def impl_getitem(self, w_key):
- self.info.gets += 1
- self._read(w_key)
- return self.content.get(w_key, None)
-
- def impl_iteritems(self):
- self.info.iteritems += 1
- self.info.iterations += 1
- return RDictItemIteratorImplementation(self.space, self)
- def impl_iterkeys(self):
- self.info.iterkeys += 1
- self.info.iterations += 1
- return RDictKeyIteratorImplementation(self.space, self)
- def impl_itervalues(self):
- self.info.itervalues += 1
- self.info.iterations += 1
- return RDictValueIteratorImplementation(self.space, self)
-
- def impl_keys(self):
- self.info.keys += 1
- self.info.listings += 1
- return self.content.keys()
- def impl_values(self):
- self.info.values += 1
- self.info.listings += 1
- return self.content.values()
- def impl_items(self):
- self.info.items += 1
- self.info.listings += 1
- return [self.space.newtuple([w_key, w_val])
- for w_key, w_val in self.content.iteritems()]
-
-
-_example = DictInfo()
-del DictInfo._dict_infos[-1]
-tmpl = 'os.write(fd, "%(attr)s" + ": " + str(info.%(attr)s) + "\\n")'
-bodySrc = []
-for attr in sorted(_example.__dict__):
- if attr == 'sig':
- continue
- bodySrc.append(tmpl%locals())
-exec py.code.Source('''
-from pypy.rlib.objectmodel import current_object_addr_as_int
-def _report_one(fd, info):
- os.write(fd, "_address" + ": " + str(current_object_addr_as_int(info))
- + "\\n")
- %s
-'''%'\n '.join(bodySrc)).compile()
-
-def report():
- if not DictInfo._dict_infos:
- return
- os.write(2, "Starting multidict report.\n")
- fd = os.open('dictinfo.txt', os.O_CREAT|os.O_WRONLY|os.O_TRUNC, 0644)
- for info in DictInfo._dict_infos:
- os.write(fd, '------------------\n')
- _report_one(fd, info)
- os.close(fd)
- os.write(2, "Reporting done.\n")
-
+ return None, None
init_signature = Signature(['seq_or_map'], None, 'kwargs')
@@ -924,7 +820,7 @@
def repr__DictViewKeys(space, w_dictview):
w_seq = space.call_function(space.w_list, w_dictview)
w_repr = space.repr(w_seq)
- return space.wrap("%s(%s)" % (space.type(w_dictview).getname(space, "?"),
+ return space.wrap("%s(%s)" % (space.type(w_dictview).getname(space),
space.str_w(w_repr)))
repr__DictViewItems = repr__DictViewKeys
repr__DictViewValues = repr__DictViewKeys
diff --git a/pypy/objspace/std/dictproxyobject.py b/pypy/objspace/std/dictproxyobject.py
--- a/pypy/objspace/std/dictproxyobject.py
+++ b/pypy/objspace/std/dictproxyobject.py
@@ -1,96 +1,98 @@
from pypy.objspace.std.model import registerimplementation, W_Object
from pypy.objspace.std.register_all import register_all
from pypy.objspace.std.dictmultiobject import W_DictMultiObject, IteratorImplementation
+from pypy.objspace.std.dictmultiobject import DictStrategy
from pypy.objspace.std.typeobject import unwrap_cell
from pypy.interpreter.error import OperationError
+from pypy.rlib import rerased
-class W_DictProxyObject(W_DictMultiObject):
- def __init__(w_self, space, w_type):
- W_DictMultiObject.__init__(w_self, space)
- w_self.w_type = w_type
- def impl_getitem(self, w_lookup):
+class DictProxyStrategy(DictStrategy):
+
+ erase, unerase = rerased.new_erasing_pair("dictproxy")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
+
+ def __init__(w_self, space):
+ DictStrategy.__init__(w_self, space)
+
+ def getitem(self, w_dict, w_key):
space = self.space
- w_lookup_type = space.type(w_lookup)
+ w_lookup_type = space.type(w_key)
if space.is_w(w_lookup_type, space.w_str):
- return self.impl_getitem_str(space.str_w(w_lookup))
+ return self.getitem_str(w_dict, space.str_w(w_key))
else:
return None
- def impl_getitem_str(self, lookup):
- return self.w_type.getdictvalue(self.space, lookup)
+ def getitem_str(self, w_dict, key):
+ return self.unerase(w_dict.dstorage).getdictvalue(self.space, key)
- def impl_setitem(self, w_key, w_value):
+ def setitem(self, w_dict, w_key, w_value):
space = self.space
if space.is_w(space.type(w_key), space.w_str):
- self.impl_setitem_str(self.space.str_w(w_key), w_value)
+ self.setitem_str(w_dict, self.space.str_w(w_key), w_value)
else:
raise OperationError(space.w_TypeError, space.wrap("cannot add non-string keys to dict of a type"))
- def impl_setitem_str(self, name, w_value):
+ def setitem_str(self, w_dict, key, w_value):
+ w_type = self.unerase(w_dict.dstorage)
try:
- self.w_type.setdictvalue(self.space, name, w_value)
+ w_type.setdictvalue(self.space, key, w_value)
except OperationError, e:
if not e.match(self.space, self.space.w_TypeError):
raise
- w_type = self.w_type
if not w_type.is_cpytype():
raise
# xxx obscure workaround: allow cpyext to write to type->tp_dict.
# xxx like CPython, we assume that this is only done early after
# xxx the type is created, and we don't invalidate any cache.
- w_type.dict_w[name] = w_value
+ w_type.dict_w[key] = w_value
- def impl_setdefault(self, w_key, w_default):
+ def setdefault(self, w_dict, w_key, w_default):
space = self.space
- w_result = self.impl_getitem(w_key)
+ w_result = self.getitem(w_dict, w_key)
if w_result is not None:
return w_result
- self.impl_setitem(w_key, w_default)
+ self.setitem(w_dict, w_key, w_default)
return w_default
- def impl_delitem(self, w_key):
+ def delitem(self, w_dict, w_key):
space = self.space
w_key_type = space.type(w_key)
if space.is_w(w_key_type, space.w_str):
- if not self.w_type.deldictvalue(space, w_key):
+ if not self.unerase(w_dict.dstorage).deldictvalue(space, w_key):
raise KeyError
else:
raise KeyError
- def impl_length(self):
- return len(self.w_type.dict_w)
+ def length(self, w_dict):
+ return len(self.unerase(w_dict.dstorage).dict_w)
- def impl_iter(self):
- return DictProxyIteratorImplementation(self.space, self)
+ def iter(self, w_dict):
+ return DictProxyIteratorImplementation(self.space, self, w_dict)
- def impl_keys(self):
+ def keys(self, w_dict):
space = self.space
- return [space.wrap(key) for key in self.w_type.dict_w.iterkeys()]
+ return [space.wrap(key) for key in self.unerase(w_dict.dstorage).dict_w.iterkeys()]
- def impl_values(self):
- return [unwrap_cell(self.space, w_value) for w_value in self.w_type.dict_w.itervalues()]
+ def values(self, w_dict):
+ return [unwrap_cell(self.space, w_value) for w_value in self.unerase(w_dict.dstorage).dict_w.itervalues()]
- def impl_items(self):
+ def items(self, w_dict):
space = self.space
return [space.newtuple([space.wrap(key), unwrap_cell(self.space, w_value)])
- for (key, w_value) in self.w_type.dict_w.iteritems()]
+ for (key, w_value) in self.unerase(w_dict.dstorage).dict_w.iteritems()]
- def impl_clear(self):
- self.w_type.dict_w.clear()
- self.w_type.mutated()
-
- def _as_rdict(self):
- assert 0, "should be unreachable"
-
- def _clear_fields(self):
- assert 0, "should be unreachable"
+ def clear(self, w_dict):
+ self.unerase(w_dict.dstorage).dict_w.clear()
+ self.unerase(w_dict.dstorage).mutated()
class DictProxyIteratorImplementation(IteratorImplementation):
- def __init__(self, space, dictimplementation):
+ def __init__(self, space, strategy, dictimplementation):
IteratorImplementation.__init__(self, space, dictimplementation)
- self.iterator = dictimplementation.w_type.dict_w.iteritems()
+ w_type = strategy.unerase(dictimplementation.dstorage)
+ self.iterator = w_type.dict_w.iteritems()
def next_entry(self):
for key, w_value in self.iterator:
diff --git a/pypy/objspace/std/frame.py b/pypy/objspace/std/frame.py
--- a/pypy/objspace/std/frame.py
+++ b/pypy/objspace/std/frame.py
@@ -6,7 +6,7 @@
from pypy.interpreter import pyopcode, function
from pypy.interpreter.pyframe import PyFrame
from pypy.interpreter.error import OperationError, operationerrfmt
-from pypy.module.__builtin__ import OPTIMIZED_BUILTINS, Module
+from pypy.module.__builtin__ import Module
from pypy.objspace.std import intobject, smallintobject
from pypy.objspace.std.multimethod import FailedToImplement
from pypy.objspace.std.dictmultiobject import W_DictMultiObject
@@ -66,41 +66,6 @@
w_result = f.space.getitem(w_1, w_2)
f.pushvalue(w_result)
-def CALL_LIKELY_BUILTIN(f, oparg, next_instr):
- w_globals = f.w_globals
- num = oparg >> 8
- assert isinstance(w_globals, W_DictMultiObject)
- w_value = w_globals.get_builtin_indexed(num)
- if w_value is None:
- builtins = f.get_builtin()
- assert isinstance(builtins, Module)
- w_builtin_dict = builtins.getdict(f.space)
- assert isinstance(w_builtin_dict, W_DictMultiObject)
- w_value = w_builtin_dict.get_builtin_indexed(num)
- if w_value is None:
- varname = OPTIMIZED_BUILTINS[num]
- message = "global name '%s' is not defined"
- raise operationerrfmt(f.space.w_NameError,
- message, varname)
- nargs = oparg & 0xff
- w_function = w_value
- try:
- w_result = call_likely_builtin(f, w_function, nargs)
- finally:
- f.dropvalues(nargs)
- f.pushvalue(w_result)
-
-def call_likely_builtin(f, w_function, nargs):
- if isinstance(w_function, function.Function):
- executioncontext = f.space.getexecutioncontext()
- executioncontext.c_call_trace(f, w_function)
- res = w_function.funccall_valuestack(nargs, f)
- executioncontext.c_return_trace(f, w_function)
- return res
- args = f.make_arguments(nargs)
- return f.space.call_args(w_function, args)
-
-
compare_table = [
"lt", # "<"
"le", # "<="
@@ -145,8 +110,6 @@
StdObjSpaceFrame.BINARY_ADD = int_BINARY_ADD
if space.config.objspace.std.optimized_list_getitem:
StdObjSpaceFrame.BINARY_SUBSCR = list_BINARY_SUBSCR
- if space.config.objspace.opcodes.CALL_LIKELY_BUILTIN:
- StdObjSpaceFrame.CALL_LIKELY_BUILTIN = CALL_LIKELY_BUILTIN
if space.config.objspace.opcodes.CALL_METHOD:
from pypy.objspace.std.callmethod import LOOKUP_METHOD, CALL_METHOD
StdObjSpaceFrame.LOOKUP_METHOD = LOOKUP_METHOD
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
@@ -4,9 +4,9 @@
from pypy.rlib import rerased
from pypy.interpreter.baseobjspace import W_Root
-from pypy.objspace.std.dictmultiobject import W_DictMultiObject
+from pypy.objspace.std.dictmultiobject import W_DictMultiObject, DictStrategy, ObjectDictStrategy
from pypy.objspace.std.dictmultiobject import IteratorImplementation
-from pypy.objspace.std.dictmultiobject import _is_sane_hash
+from pypy.objspace.std.dictmultiobject import _never_equal_to_string
from pypy.objspace.std.objectobject import W_ObjectObject
from pypy.objspace.std.typeobject import TypeCell
@@ -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
@@ -154,7 +154,7 @@
obj._set_mapdict_map(attr)
obj._mapdict_write_storage(attr.position, w_value)
- def materialize_r_dict(self, space, obj, w_d):
+ def materialize_r_dict(self, space, obj, dict_w):
raise NotImplementedError("abstract base class")
def remove_dict_entries(self, obj):
@@ -205,7 +205,7 @@
Terminator.__init__(self, space, w_cls)
self.devolved_dict_terminator = DevolvedDictTerminator(space, w_cls)
- def materialize_r_dict(self, space, obj, w_d):
+ def materialize_r_dict(self, space, obj, dict_w):
result = Object()
result.space = space
result._init_empty(self.devolved_dict_terminator)
@@ -297,11 +297,11 @@
return self
return self.back.search(attrtype)
- def materialize_r_dict(self, space, obj, w_d):
- new_obj = self.back.materialize_r_dict(space, obj, w_d)
+ def materialize_r_dict(self, space, obj, dict_w):
+ new_obj = self.back.materialize_r_dict(space, obj, dict_w)
if self.selector[1] == DICT:
w_attr = space.wrap(self.selector[0])
- w_d.r_dict_content[w_attr] = obj._mapdict_read_storage(self.position)
+ dict_w[w_attr] = obj._mapdict_read_storage(self.position)
else:
self._copy_attr(obj, new_obj)
return new_obj
@@ -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
# _____________________________________________
@@ -382,7 +382,10 @@
if w_dict is not None:
assert isinstance(w_dict, W_DictMultiObject)
return w_dict
- w_dict = MapDictImplementation(space, self)
+
+ strategy = space.fromcache(MapDictStrategy)
+ storage = strategy.erase(self)
+ w_dict = W_DictMultiObject(space, strategy, storage)
flag = self._get_mapdict_map().write(self, ("dict", SPECIAL), w_dict)
assert flag
return w_dict
@@ -392,8 +395,8 @@
w_dict = check_new_dictionary(space, w_dict)
w_olddict = self.getdict(space)
assert isinstance(w_dict, W_DictMultiObject)
- if w_olddict.r_dict_content is None:
- w_olddict._as_rdict()
+ if type(w_olddict.strategy) is not ObjectDictStrategy:
+ w_olddict.strategy.switch_to_object_strategy(w_olddict)
flag = self._get_mapdict_map().write(self, ("dict", SPECIAL), w_dict)
assert flag
@@ -575,105 +578,121 @@
# ____________________________________________________________
# dict implementation
+class MapDictStrategy(DictStrategy):
-class MapDictImplementation(W_DictMultiObject):
- def __init__(self, space, w_obj):
+ erase, unerase = rerased.new_erasing_pair("map")
+ erase = staticmethod(erase)
+ unerase = staticmethod(unerase)
+
+ def __init__(self, space):
self.space = space
- self.w_obj = w_obj
- def impl_getitem(self, w_lookup):
+ def switch_to_object_strategy(self, w_dict):
+ w_obj = self.unerase(w_dict.dstorage)
+ strategy = self.space.fromcache(ObjectDictStrategy)
+ dict_w = strategy.unerase(strategy.get_empty_storage())
+ w_dict.strategy = strategy
+ w_dict.dstorage = strategy.erase(dict_w)
+ assert w_obj.getdict(self.space) is w_dict
+ materialize_r_dict(self.space, w_obj, dict_w)
+
+ def getitem(self, w_dict, w_key):
space = self.space
- w_lookup_type = space.type(w_lookup)
+ w_lookup_type = space.type(w_key)
if space.is_w(w_lookup_type, space.w_str):
- return self.impl_getitem_str(space.str_w(w_lookup))
- elif _is_sane_hash(space, w_lookup_type):
+ return self.getitem_str(w_dict, space.str_w(w_key))
+ elif _never_equal_to_string(space, w_lookup_type):
return None
else:
- return self._as_rdict().impl_fallback_getitem(w_lookup)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.getitem(w_key)
- def impl_getitem_str(self, key):
- return self.w_obj.getdictvalue(self.space, key)
+ def getitem_str(self, w_dict, key):
+ w_obj = self.unerase(w_dict.dstorage)
+ return w_obj.getdictvalue(self.space, key)
- def impl_setitem_str(self, key, w_value):
- flag = self.w_obj.setdictvalue(self.space, key, w_value)
+ def setitem_str(self, w_dict, key, w_value):
+ w_obj = self.unerase(w_dict.dstorage)
+ flag = w_obj.setdictvalue(self.space, key, w_value)
assert flag
- def impl_setitem(self, w_key, w_value):
+ def setitem(self, w_dict, w_key, w_value):
space = self.space
if space.is_w(space.type(w_key), space.w_str):
- self.impl_setitem_str(self.space.str_w(w_key), w_value)
+ self.setitem_str(w_dict, self.space.str_w(w_key), w_value)
else:
- self._as_rdict().impl_fallback_setitem(w_key, w_value)
+ self.switch_to_object_strategy(w_dict)
+ w_dict.setitem(w_key, w_value)
- def impl_setdefault(self, w_key, w_default):
+ def setdefault(self, w_dict, w_key, w_default):
space = self.space
if space.is_w(space.type(w_key), space.w_str):
key = space.str_w(w_key)
- w_result = self.impl_getitem_str(key)
+ w_result = self.getitem_str(w_dict, key)
if w_result is not None:
return w_result
- self.impl_setitem_str(key, w_default)
+ self.setitem_str(w_dict, key, w_default)
return w_default
else:
- return self._as_rdict().impl_fallback_setdefault(w_key, w_default)
+ self.switch_to_object_strategy(w_dict)
+ return w_dict.setdefault(w_key, w_default)
- def impl_delitem(self, w_key):
+ def delitem(self, w_dict, w_key):
space = self.space
w_key_type = space.type(w_key)
+ w_obj = self.unerase(w_dict.dstorage)
if space.is_w(w_key_type, space.w_str):
- flag = self.w_obj.deldictvalue(space, w_key)
+ flag = w_obj.deldictvalue(space, w_key)
if not flag:
raise KeyError
- elif _is_sane_hash(space, w_key_type):
+ elif _never_equal_to_string(space, w_key_type):
raise KeyError
else:
- self._as_rdict().impl_fallback_delitem(w_key)
+ self.switch_to_object_strategy(w_dict)
+ w_dict.delitem(w_key)
- def impl_length(self):
+ def length(self, w_dict):
res = 0
- curr = self.w_obj._get_mapdict_map().search(DICT)
+ curr = self.unerase(w_dict.dstorage)._get_mapdict_map().search(DICT)
while curr is not None:
curr = curr.back
curr = curr.search(DICT)
res += 1
return res
- def impl_iter(self):
- return MapDictIteratorImplementation(self.space, self)
+ def iter(self, w_dict):
+ return MapDictIteratorImplementation(self.space, self, w_dict)
- def impl_clear(self):
- w_obj = self.w_obj
+ def clear(self, w_dict):
+ w_obj = self.unerase(w_dict.dstorage)
new_obj = w_obj._get_mapdict_map().remove_dict_entries(w_obj)
_become(w_obj, new_obj)
- def _clear_fields(self):
- self.w_obj = None
+ def popitem(self, w_dict):
+ curr = self.unerase(w_dict.dstorage)._get_mapdict_map().search(DICT)
+ if curr is None:
+ raise KeyError
+ key = curr.selector[0]
+ w_value = self.getitem_str(w_dict, key)
+ w_key = self.space.wrap(key)
+ self.delitem(w_dict, w_key)
+ return (w_key, w_value)
- def _as_rdict(self):
- self.initialize_as_rdict()
- space = self.space
- w_obj = self.w_obj
- materialize_r_dict(space, w_obj, self)
- self._clear_fields()
- return self
-
-
-def materialize_r_dict(space, obj, w_d):
+def materialize_r_dict(space, obj, dict_w):
map = obj._get_mapdict_map()
- assert obj.getdict(space) is w_d
- new_obj = map.materialize_r_dict(space, obj, w_d)
+ new_obj = map.materialize_r_dict(space, obj, dict_w)
_become(obj, new_obj)
class MapDictIteratorImplementation(IteratorImplementation):
- def __init__(self, space, dictimplementation):
+ def __init__(self, space, strategy, dictimplementation):
IteratorImplementation.__init__(self, space, dictimplementation)
- w_obj = dictimplementation.w_obj
+ w_obj = strategy.unerase(dictimplementation.dstorage)
self.w_obj = w_obj
self.orig_map = self.curr_map = w_obj._get_mapdict_map()
def next_entry(self):
implementation = self.dictimplementation
- assert isinstance(implementation, MapDictImplementation)
+ assert isinstance(implementation.strategy, MapDictStrategy)
if self.orig_map is not self.w_obj._get_mapdict_map():
return None, None
if self.curr_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
@@ -255,7 +255,7 @@
w_result = self.wrap_exception_cls(x)
if w_result is not None:
return w_result
- from fake import fake_object
+ from pypy.objspace.std.fake import fake_object
return fake_object(self, x)
def wrap_exception_cls(self, x):
@@ -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/ropeunicodeobject.py b/pypy/objspace/std/ropeunicodeobject.py
--- a/pypy/objspace/std/ropeunicodeobject.py
+++ b/pypy/objspace/std/ropeunicodeobject.py
@@ -986,7 +986,7 @@
## return space.wrap(0)
## return space.wrap(result)
-import unicodetype
+from pypy.objspace.std import unicodetype
register_all(vars(), unicodetype)
# str.strip(unicode) needs to convert self to unicode and call unicode.strip we
@@ -997,7 +997,7 @@
# methods?
class str_methods:
- import stringtype
+ from pypy.objspace.std import stringtype
W_RopeUnicodeObject = W_RopeUnicodeObject
from pypy.objspace.std.ropeobject import W_RopeObject
def str_strip__Rope_RopeUnicode(space, w_self, w_chars):
diff --git a/pypy/objspace/std/setobject.py b/pypy/objspace/std/setobject.py
--- a/pypy/objspace/std/setobject.py
+++ b/pypy/objspace/std/setobject.py
@@ -466,12 +466,11 @@
return space.wrap(hash)
def set_pop__Set(space, w_left):
- for w_key in w_left.setdata:
- break
- else:
+ try:
+ w_key, _ = w_left.setdata.popitem()
+ except KeyError:
raise OperationError(space.w_KeyError,
space.wrap('pop from an empty set'))
- del w_left.setdata[w_key]
return w_key
def and__Set_Set(space, w_left, w_other):
diff --git a/pypy/objspace/std/test/test_celldict.py b/pypy/objspace/std/test/test_celldict.py
--- a/pypy/objspace/std/test/test_celldict.py
+++ b/pypy/objspace/std/test/test_celldict.py
@@ -1,6 +1,7 @@
import py
from pypy.conftest import gettestobjspace, option
-from pypy.objspace.std.celldict import ModuleCell, ModuleDictImplementation
+from pypy.objspace.std.dictmultiobject import W_DictMultiObject
+from pypy.objspace.std.celldict import ModuleCell, ModuleDictStrategy
from pypy.objspace.std.test.test_dictmultiobject import FakeSpace
from pypy.interpreter import gateway
@@ -8,7 +9,15 @@
class TestCellDict(object):
def test_basic_property(self):
- d = ModuleDictImplementation(space)
+ strategy = ModuleDictStrategy(space)
+ storage = strategy.get_empty_storage()
+ d = W_DictMultiObject(space, strategy, storage)
+
+ # replace getcell with getcell from strategy
+ def f(key, makenew):
+ return strategy.getcell(d, key, makenew)
+ d.getcell = f
+
d.setitem("a", 1)
assert d.getcell("a", False) is d.getcell("a", False)
acell = d.getcell("a", False)
@@ -29,3 +38,33 @@
assert d.getitem("a") is None
assert d.getcell("a", False) is acell
assert d.length() == 0
+
+class AppTestCellDict(object):
+ OPTIONS = {"objspace.std.withcelldict": True}
+
+ def setup_class(cls):
+ if option.runappdirect:
+ py.test.skip("__repr__ doesn't work on appdirect")
+ strategy = ModuleDictStrategy(cls.space)
+ storage = strategy.get_empty_storage()
+ cls.w_d = W_DictMultiObject(cls.space, strategy, storage)
+
+ def test_popitem(self):
+ import __pypy__
+
+ d = self.d
+ assert "ModuleDict" in __pypy__.internal_repr(d)
+ raises(KeyError, d.popitem)
+ d["a"] = 3
+ x = d.popitem()
+ assert x == ("a", 3)
+
+ def test_degenerate(self):
+ import __pypy__
+
+ d = self.d
+ assert "ModuleDict" in __pypy__.internal_repr(d)
+ d["a"] = 3
+ del d["a"]
+ d[object()] = 5
+ assert d.values() == [5]
\ No newline at end of file
diff --git a/pypy/objspace/std/test/test_dictmultiobject.py b/pypy/objspace/std/test/test_dictmultiobject.py
--- a/pypy/objspace/std/test/test_dictmultiobject.py
+++ b/pypy/objspace/std/test/test_dictmultiobject.py
@@ -1,12 +1,13 @@
+import py
import sys
from pypy.interpreter.error import OperationError
from pypy.objspace.std.dictmultiobject import \
W_DictMultiObject, setitem__DictMulti_ANY_ANY, getitem__DictMulti_ANY, \
- StrDictImplementation
+ StringDictStrategy, ObjectDictStrategy
-from pypy.objspace.std.celldict import ModuleDictImplementation
+from pypy.objspace.std.celldict import ModuleDictStrategy
from pypy.conftest import gettestobjspace
-
+from pypy.conftest import option
class TestW_DictObject:
@@ -17,7 +18,7 @@
space = self.space
d = self.space.newdict()
assert not self.space.is_true(d)
- assert d.r_dict_content is None
+ assert type(d.strategy) is not ObjectDictStrategy
def test_nonempty(self):
space = self.space
@@ -137,31 +138,31 @@
cls.w_on_pypy = cls.space.wrap("__pypy__" in sys.builtin_module_names)
def test_equality(self):
- d = {1:2}
- f = {1:2}
+ d = {1: 2}
+ f = {1: 2}
assert d == f
- assert d != {1:3}
+ assert d != {1: 3}
def test_clear(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
d.clear()
assert len(d) == 0
def test_copy(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
assert d == dd
assert not d is dd
def test_get(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
assert d.get(1) == 2
- assert d.get(1,44) == 2
+ assert d.get(1, 44) == 2
assert d.get(33) == None
- assert d.get(33,44) == 44
+ assert d.get(33, 44) == 44
def test_pop(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
result = dd.pop(1)
assert result == 2
@@ -176,18 +177,18 @@
raises(KeyError, dd.pop, 33)
def test_has_key(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
assert d.has_key(1)
assert not d.has_key(33)
def test_items(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
its = d.items()
its.sort()
- assert its == [(1,2),(3,4)]
+ assert its == [(1, 2), (3, 4)]
def test_iteritems(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
for k, v in d.iteritems():
assert v == dd[k]
@@ -195,33 +196,33 @@
assert not dd
def test_iterkeys(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
for k in d.iterkeys():
del dd[k]
assert not dd
def test_itervalues(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
values = []
for k in d.itervalues():
values.append(k)
assert values == d.values()
def test_keys(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
kys = d.keys()
kys.sort()
- assert kys == [1,3]
+ assert kys == [1, 3]
def test_popitem(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
it = d.popitem()
assert len(d) == 1
- assert it==(1,2) or it==(3,4)
+ assert it == (1, 2) or it == (3, 4)
it1 = d.popitem()
assert len(d) == 0
- assert (it!=it1) and (it1==(1,2) or it1==(3,4))
+ assert (it != it1) and (it1 == (1, 2) or it1 == (3, 4))
raises(KeyError, d.popitem)
def test_popitem_2(self):
@@ -233,8 +234,33 @@
assert it1 == ('x', 5)
raises(KeyError, d.popitem)
+ def test_popitem3(self):
+ #object
+ d = {"a": 1, 2: 2, "c": 3}
+ l = []
+ while True:
+ try:
+ l.append(d.popitem())
+ except KeyError:
+ break;
+ assert ("a", 1) in l
+ assert (2, 2) in l
+ assert ("c", 3) in l
+
+ #string
+ d = {"a": 1, "b":2, "c":3}
+ l = []
+ while True:
+ try:
+ l.append(d.popitem())
+ except KeyError:
+ break;
+ assert ("a", 1) in l
+ assert ("b", 2) in l
+ assert ("c", 3) in l
+
def test_setdefault(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
x = dd.setdefault(1, 99)
assert d == dd
@@ -267,12 +293,12 @@
assert k.calls == 1
def test_update(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
dd = d.copy()
d.update({})
assert d == dd
- d.update({3:5, 6:7})
- assert d == {1:2, 3:5, 6:7}
+ d.update({3: 5, 6: 7})
+ assert d == {1: 2, 3: 5, 6: 7}
def test_update_iterable(self):
d = {}
@@ -297,15 +323,15 @@
assert d == {'foo': 'bar', 'baz': 1}
def test_values(self):
- d = {1:2, 3:4}
+ d = {1: 2, 3: 4}
vals = d.values()
vals.sort()
assert vals == [2,4]
def test_eq(self):
- d1 = {1:2, 3:4}
- d2 = {1:2, 3:4}
- d3 = {1:2}
+ d1 = {1: 2, 3: 4}
+ d2 = {1: 2, 3: 4}
+ d3 = {1: 2}
bool = d1 == d2
assert bool == True
bool = d1 == d3
@@ -316,10 +342,10 @@
assert bool == True
def test_lt(self):
- d1 = {1:2, 3:4}
- d2 = {1:2, 3:4}
- d3 = {1:2, 3:5}
- d4 = {1:2}
+ d1 = {1: 2, 3: 4}
+ d2 = {1: 2, 3: 4}
+ d3 = {1: 2, 3: 5}
+ d4 = {1: 2}
bool = d1 < d2
assert bool == False
bool = d1 < d3
@@ -366,21 +392,17 @@
def test_new(self):
d = dict()
assert d == {}
- args = [['a',2], [23,45]]
+ args = [['a', 2], [23, 45]]
d = dict(args)
- assert d == {'a':2, 23:45}
+ assert d == {'a': 2, 23: 45}
d = dict(args, a=33, b=44)
- assert d == {'a':33, 'b':44, 23:45}
+ assert d == {'a': 33, 'b': 44, 23: 45}
d = dict(a=33, b=44)
- assert d == {'a':33, 'b':44}
- d = dict({'a':33, 'b':44})
- assert d == {'a':33, 'b':44}
- try: d = dict(23)
- except (TypeError, ValueError): pass
- else: self.fail("dict(23) should raise!")
- try: d = dict([[1,2,3]])
- except (TypeError, ValueError): pass
- else: self.fail("dict([[1,2,3]]) should raise!")
+ assert d == {'a': 33, 'b': 44}
+ d = dict({'a': 33, 'b': 44})
+ assert d == {'a': 33, 'b': 44}
+ raises((TypeError, ValueError), dict, 23)
+ raises((TypeError, ValueError), dict, [[1, 2, 3]])
def test_fromkeys(self):
assert {}.fromkeys([1, 2], 1) == {1: 1, 2: 1}
@@ -527,6 +549,12 @@
__missing__ = SpecialDescr(missing)
assert X()['hi'] == 42
+ def test_empty_dict(self):
+ d = {}
+ raises(KeyError, d.popitem)
+ assert d.items() == []
+ assert d.values() == []
+ assert d.keys() == []
class AppTest_DictMultiObject(AppTest_DictObject):
@@ -706,10 +734,12 @@
class AppTestModuleDict(object):
def setup_class(cls):
cls.space = gettestobjspace(**{"objspace.std.withcelldict": True})
+ if option.runappdirect:
+ py.test.skip("__repr__ doesn't work on appdirect")
def w_impl_used(self, obj):
import __pypy__
- assert "ModuleDictImplementation" in __pypy__.internal_repr(obj)
+ assert "ModuleDictStrategy" in __pypy__.internal_repr(obj)
def test_check_module_uses_module_dict(self):
m = type(__builtins__)("abc")
@@ -719,6 +749,64 @@
d = type(__builtins__)("abc").__dict__
raises(KeyError, "d['def']")
+ def test_fallback_evil_key(self):
+ class F(object):
+ def __hash__(self):
+ return hash("s")
+ def __eq__(self, other):
+ return other == "s"
+ d = type(__builtins__)("abc").__dict__
+ d["s"] = 12
+ assert d["s"] == 12
+ assert d[F()] == d["s"]
+
+ d = type(__builtins__)("abc").__dict__
+ x = d.setdefault("s", 12)
+ assert x == 12
+ x = d.setdefault(F(), 12)
+ assert x == 12
+
+ d = type(__builtins__)("abc").__dict__
+ x = d.setdefault(F(), 12)
+ assert x == 12
+
+ d = type(__builtins__)("abc").__dict__
+ d["s"] = 12
+ del d[F()]
+
+ assert "s" not in d
+ assert F() not in d
+
+class AppTestStrategies(object):
+ def setup_class(cls):
+ if option.runappdirect:
+ py.test.skip("__repr__ doesn't work on appdirect")
+
+ def w_get_strategy(self, obj):
+ import __pypy__
+ r = __pypy__.internal_repr(obj)
+ return r[r.find("(") + 1: r.find(")")]
+
+ def test_empty_to_string(self):
+ d = {}
+ assert "EmptyDictStrategy" in self.get_strategy(d)
+ d["a"] = 1
+ assert "StringDictStrategy" in self.get_strategy(d)
+
+ class O(object):
+ pass
+ o = O()
+ d = o.__dict__ = {}
+ assert "EmptyDictStrategy" in self.get_strategy(d)
+ o.a = 1
+ assert "StringDictStrategy" in self.get_strategy(d)
+
+ def test_empty_to_int(self):
+ import sys
+ d = {}
+ d[1] = "hi"
+ assert "IntDictStrategy" in self.get_strategy(d)
+ assert d[1L] == "hi"
class FakeString(str):
@@ -759,6 +847,10 @@
assert isinstance(string, str)
return string
+ def int_w(self, integer):
+ assert isinstance(integer, int)
+ return integer
+
def wrap(self, obj):
return obj
@@ -790,6 +882,10 @@
w_StopIteration = StopIteration
w_None = None
+ w_NoneType = type(None, None)
+ w_int = int
+ w_bool = bool
+ w_float = float
StringObjectCls = FakeString
w_dict = W_DictMultiObject
iter = iter
@@ -799,12 +895,9 @@
class Config:
class objspace:
class std:
- withdictmeasurement = False
withsmalldicts = False
withcelldict = False
withmethodcache = False
- class opcodes:
- CALL_LIKELY_BUILTIN = False
FakeSpace.config = Config()
@@ -834,14 +927,20 @@
self.impl = self.get_impl()
def get_impl(self):
- return self.ImplementionClass(self.fakespace)
+ strategy = self.StrategyClass(self.fakespace)
+ storage = strategy.get_empty_storage()
+ w_dict = self.fakespace.allocate_instance(W_DictMultiObject, None)
+ W_DictMultiObject.__init__(w_dict, self.fakespace, strategy, storage)
+ return w_dict
def fill_impl(self):
self.impl.setitem(self.string, 1000)
self.impl.setitem(self.string2, 2000)
def check_not_devolved(self):
- assert self.impl.r_dict_content is None
+ #XXX check if strategy changed!?
+ assert type(self.impl.strategy) is self.StrategyClass
+ #assert self.impl.r_dict_content is None
def test_setitem(self):
self.impl.setitem(self.string, 1000)
@@ -913,7 +1012,7 @@
for x in xrange(100):
impl.setitem(self.fakespace.str_w(str(x)), x)
impl.setitem(x, x)
- assert impl.r_dict_content is not None
+ assert type(impl.strategy) is ObjectDictStrategy
def test_setdefault_fast(self):
on_pypy = "__pypy__" in sys.builtin_module_names
@@ -928,8 +1027,38 @@
if on_pypy:
assert key.hash_count == 2
+ def test_fallback_evil_key(self):
+ class F(object):
+ def __hash__(self):
+ return hash("s")
+ def __eq__(self, other):
+ return other == "s"
+
+ d = self.get_impl()
+ d.setitem("s", 12)
+ assert d.getitem("s") == 12
+ assert d.getitem(F()) == d.getitem("s")
+
+ d = self.get_impl()
+ x = d.setdefault("s", 12)
+ assert x == 12
+ x = d.setdefault(F(), 12)
+ assert x == 12
+
+ d = self.get_impl()
+ x = d.setdefault(F(), 12)
+ assert x == 12
+
+ d = self.get_impl()
+ d.setitem("s", 12)
+ d.delitem(F())
+
+ assert "s" not in d.keys()
+ assert F() not in d.keys()
+
class TestStrDictImplementation(BaseTestRDictImplementation):
- ImplementionClass = StrDictImplementation
+ StrategyClass = StringDictStrategy
+ #ImplementionClass = StrDictImplementation
def test_str_shortcut(self):
self.fill_impl()
@@ -942,10 +1071,10 @@
## DevolvedClass = MeasuringDictImplementation
class TestModuleDictImplementation(BaseTestRDictImplementation):
- ImplementionClass = ModuleDictImplementation
+ StrategyClass = ModuleDictStrategy
class TestModuleDictImplementationWithBuiltinNames(BaseTestRDictImplementation):
- ImplementionClass = ModuleDictImplementation
+ StrategyClass = ModuleDictStrategy
string = "int"
string2 = "isinstance"
@@ -954,19 +1083,19 @@
class BaseTestDevolvedDictImplementation(BaseTestRDictImplementation):
def fill_impl(self):
BaseTestRDictImplementation.fill_impl(self)
- self.impl._as_rdict()
+ self.impl.strategy.switch_to_object_strategy(self.impl)
def check_not_devolved(self):
pass
class TestDevolvedStrDictImplementation(BaseTestDevolvedDictImplementation):
- ImplementionClass = StrDictImplementation
+ StrategyClass = StringDictStrategy
class TestDevolvedModuleDictImplementation(BaseTestDevolvedDictImplementation):
- ImplementionClass = ModuleDictImplementation
+ StrategyClass = ModuleDictStrategy
class TestDevolvedModuleDictImplementationWithBuiltinNames(BaseTestDevolvedDictImplementation):
- ImplementionClass = ModuleDictImplementation
+ StrategyClass = ModuleDictStrategy
string = "int"
string2 = "isinstance"
@@ -975,5 +1104,4 @@
def test_module_uses_strdict():
fakespace = FakeSpace()
d = fakespace.newdict(module=True)
- assert isinstance(d, StrDictImplementation)
-
+ assert type(d.strategy) is StringDictStrategy
diff --git a/pypy/objspace/std/test/test_mapdict.py b/pypy/objspace/std/test/test_mapdict.py
--- a/pypy/objspace/std/test/test_mapdict.py
+++ b/pypy/objspace/std/test/test_mapdict.py
@@ -250,13 +250,18 @@
class FakeDict(W_DictMultiObject):
def __init__(self, d):
- self.r_dict_content = d
+ self.dstorage = d
+
+ class strategy:
+ def unerase(self, x):
+ return d
+ strategy = strategy()
d = {}
w_d = FakeDict(d)
flag = obj.map.write(obj, ("dict", SPECIAL), w_d)
assert flag
- materialize_r_dict(space, obj, w_d)
+ materialize_r_dict(space, obj, d)
assert d == {"a": 5, "b": 6, "c": 7}
assert obj.storage == [50, 60, 70, w_d]
@@ -291,18 +296,18 @@
w_obj = cls.instantiate(self.fakespace)
return w_obj.getdict(self.fakespace)
class TestMapDictImplementation(BaseTestRDictImplementation):
- ImplementionClass = MapDictImplementation
+ StrategyClass = MapDictStrategy
get_impl = get_impl
class TestDevolvedMapDictImplementation(BaseTestDevolvedDictImplementation):
get_impl = get_impl
- ImplementionClass = MapDictImplementation
+ StrategyClass = MapDictStrategy
# ___________________________________________________________
# tests that check the obj interface after the dict has devolved
def devolve_dict(space, obj):
w_d = obj.getdict(space)
- w_d._as_rdict()
+ w_d.strategy.switch_to_object_strategy(w_d)
def test_get_setdictvalue_after_devolve():
cls = Class()
@@ -463,6 +468,20 @@
d['dd'] = 43
assert a.dd == 41
+ def test_popitem(self):
+ class A(object):
+ pass
+ a = A()
+ a.x = 5
+ a.y = 6
+ it1 = a.__dict__.popitem()
+ assert it1 == ("y", 6)
+ it2 = a.__dict__.popitem()
+ assert it2 == ("x", 5)
+ assert a.__dict__ == {}
+ raises(KeyError, a.__dict__.popitem)
+
+
def test_slot_name_conflict(self):
class A(object):
@@ -604,6 +623,14 @@
assert a.__dict__ is d
assert isinstance(a, B)
+ def test_setdict(self):
+ class A(object):
+ pass
+
+ a = A()
+ a.__dict__ = {}
+ a.__dict__ = {}
+
class AppTestWithMapDictAndCounters(object):
def setup_class(cls):
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)
@@ -423,10 +423,13 @@
return False
def getdict(w_self, space): # returning a dict-proxy!
- from pypy.objspace.std.dictproxyobject import W_DictProxyObject
+ from pypy.objspace.std.dictproxyobject import DictProxyStrategy
+ from pypy.objspace.std.dictmultiobject import W_DictMultiObject
if w_self.lazyloaders:
w_self._freeze_() # force un-lazification
- return W_DictProxyObject(space, w_self)
+ strategy = space.fromcache(DictProxyStrategy)
+ storage = strategy.erase(w_self)
+ return W_DictMultiObject(space, strategy, storage)
def unwrap(w_self, space):
if w_self.instancetypedef.fakedcpytype is not None:
@@ -447,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()
@@ -774,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:
@@ -820,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/objspace/std/unicodeobject.py b/pypy/objspace/std/unicodeobject.py
--- a/pypy/objspace/std/unicodeobject.py
+++ b/pypy/objspace/std/unicodeobject.py
@@ -937,7 +937,7 @@
return formatter.format_string(space.unicode_w(w_unicode))
-import unicodetype
+from pypy.objspace.std import unicodetype
register_all(vars(), unicodetype)
# str.strip(unicode) needs to convert self to unicode and call unicode.strip we
@@ -948,7 +948,7 @@
# methods?
class str_methods:
- import stringtype
+ from pypy.objspace.std import stringtype
W_UnicodeObject = W_UnicodeObject
from pypy.objspace.std.stringobject import W_StringObject
from pypy.objspace.std.ropeobject import W_RopeObject
diff --git a/pypy/objspace/taint.py b/pypy/objspace/taint.py
--- a/pypy/objspace/taint.py
+++ b/pypy/objspace/taint.py
@@ -92,8 +92,8 @@
w_realtype = space.type(w_obj)
if not space.is_w(w_realtype, w_expectedtype):
#msg = "expected an object of type '%s'" % (
- # w_expectedtype.getname(space, '?'),)
- # #w_realtype.getname(space, '?'))
+ # w_expectedtype.getname(space),)
+ # #w_realtype.getname(space))
raise OperationError(space.w_TaintError, space.w_None)
return w_obj
app_untaint = gateway.interp2app(untaint)
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
@@ -277,12 +292,13 @@
'function_threshold': 1617, # slightly more than one above
'trace_eagerness': 200,
'trace_limit': 12000,
- 'inlining': 0,
+ 'inlining': 1,
'loop_longevity': 1000,
'retrace_limit': 5,
- 'enable_opts': None, # patched later by optimizeopt/__init__.py
+ 'enable_opts': 'all',
}
unroll_parameters = unrolling_iterable(PARAMETERS.items())
+DEFAULT = object()
# ____________________________________________________________
@@ -337,22 +353,33 @@
def _set_param(self, name, value):
# special-cased by ExtRegistryEntry
# (internal, must receive a constant 'name')
+ # if value is DEFAULT, sets the default value.
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:
- if name1 == name:
- self._set_param(name1, value)
- return
- raise ValueError("no such parameter")
+ self._set_param(name, value)
+
+ @specialize.arg(0, 1)
+ def set_param_to_default(self, name):
+ """Reset one of the tunable JIT parameters to its default value."""
+ self._set_param(name, DEFAULT)
def set_user_param(self, text):
"""Set the tunable JIT parameters from a user-supplied string
- following the format 'param=value,param=value'. For programmatic
- setting of parameters, use directly JitDriver.set_param().
+ following the format 'param=value,param=value', or 'off' to
+ disable the JIT. For programmatic setting of parameters, use
+ directly JitDriver.set_param().
"""
+ if text == 'off':
+ self.set_param('threshold', -1)
+ self.set_param('function_threshold', -1)
+ return
+ if text == 'default':
+ for name1, _ in unroll_parameters:
+ self.set_param_to_default(name1)
+ return
for s in text.split(','):
s = s.strip(' ')
parts = s.split('=')
@@ -575,15 +602,17 @@
def compute_result_annotation(self, s_name, s_value):
from pypy.annotation import model as annmodel
assert s_name.is_constant()
- if s_name.const == 'enable_opts':
- assert annmodel.SomeString(can_be_None=True).contains(s_value)
- else:
- assert annmodel.SomeInteger().contains(s_value)
+ if not self.bookkeeper.immutablevalue(DEFAULT).contains(s_value):
+ if s_name.const == 'enable_opts':
+ assert annmodel.SomeString(can_be_None=True).contains(s_value)
+ else:
+ assert annmodel.SomeInteger().contains(s_value)
return annmodel.s_None
def specialize_call(self, hop):
from pypy.rpython.lltypesystem import lltype
from pypy.rpython.lltypesystem.rstr import string_repr
+ from pypy.objspace.flow.model import Constant
hop.exception_cannot_occur()
driver = self.instance.im_self
@@ -592,7 +621,12 @@
repr = string_repr
else:
repr = lltype.Signed
- v_value = hop.inputarg(repr, arg=1)
+ if (isinstance(hop.args_v[1], Constant) and
+ hop.args_v[1].value is DEFAULT):
+ value = PARAMETERS[name]
+ v_value = hop.inputconst(repr, value)
+ else:
+ v_value = hop.inputarg(repr, arg=1)
vlist = [hop.inputconst(lltype.Void, "set_param"),
hop.inputconst(lltype.Void, driver),
hop.inputconst(lltype.Void, name),
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
@@ -850,10 +850,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
@@ -862,8 +868,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/memory/gc/minimark.py b/pypy/rpython/memory/gc/minimark.py
--- a/pypy/rpython/memory/gc/minimark.py
+++ b/pypy/rpython/memory/gc/minimark.py
@@ -256,10 +256,6 @@
# (may) contain a pointer to a young object. Populated by
# the write barrier: when we clear GCFLAG_TRACK_YOUNG_PTRS, we
# add it to this list.
- class Cls(self.AddressStack):
- def append(self2, addr):
- assert addr not in self2.tolist()
- self.AddressStack.append(self2, addr)
self.objects_pointing_to_young = self.AddressStack()
#
# Similar to 'objects_pointing_to_young', but lists objects
diff --git a/pypy/rpython/ootypesystem/rclass.py b/pypy/rpython/ootypesystem/rclass.py
--- a/pypy/rpython/ootypesystem/rclass.py
+++ b/pypy/rpython/ootypesystem/rclass.py
@@ -264,7 +264,8 @@
for name, attrdef in selfattrs.iteritems():
if not attrdef.readonly and self.is_quasi_immutable(name):
- ootype.addFields(self.lowleveltype, {'mutable_'+name: OBJECT})
+ name = mangle('mutable_' + name, self.rtyper.getconfig())
+ ootype.addFields(self.lowleveltype, {name: OBJECT})
classattributes = {}
baseInstance = self.lowleveltype._superclass
diff --git a/pypy/rpython/ootypesystem/test/test_oopbc.py b/pypy/rpython/ootypesystem/test/test_oopbc.py
--- a/pypy/rpython/ootypesystem/test/test_oopbc.py
+++ b/pypy/rpython/ootypesystem/test/test_oopbc.py
@@ -81,3 +81,18 @@
res = interpret(f, [1], type_system='ootype')
assert res == 2
+def test_quasi_immutable():
+ class A(object):
+ _immutable_fields_ = ['x?']
+ def __init__(self):
+ self.x = 3
+ def foo(self):
+ return self.x
+
+ a = A()
+
+ def f():
+ return a.foo()
+
+ res = interpret(f, [], type_system='ootype')
+ assert res == 3
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):
diff --git a/pypy/tool/jitlogparser/parser.py b/pypy/tool/jitlogparser/parser.py
--- a/pypy/tool/jitlogparser/parser.py
+++ b/pypy/tool/jitlogparser/parser.py
@@ -1,10 +1,13 @@
import re, sys
-from pypy.jit.metainterp.resoperation import rop, opname
+from pypy.jit.metainterp.resoperation import opname
from pypy.jit.tool.oparser import OpParser
+from pypy.tool.logparser import parse_log_file, extract_category
class Op(object):
bridge = None
+ offset = None
+ asm = None
def __init__(self, name, args, res, descr):
self.name = name
@@ -54,10 +57,53 @@
Op = Op
use_mock_model = True
+ def postprocess(self, loop, backend_dump=None, backend_tp=None,
+ dump_start=0):
+ if backend_dump is not None:
+ raw_asm = self._asm_disassemble(backend_dump.decode('hex'),
+ backend_tp, dump_start)
+ asm = []
+ start = 0
+ for elem in raw_asm:
+ if len(elem.split("\t")) != 3:
+ continue
+ adr, _, v = elem.split("\t")
+ if not start:
+ start = int(adr.strip(":"), 16)
+ ofs = int(adr.strip(":"), 16) - start
+ if ofs >= 0:
+ asm.append((ofs, v.strip("\n")))
+ asm_index = 0
+ for i, op in enumerate(loop.operations):
+ end = 0
+ j = i + 1
+ while end == 0:
+ if j == len(loop.operations):
+ end = loop.last_offset
+ break
+ if loop.operations[j].offset is None:
+ j += 1
+ else:
+ end = loop.operations[j].offset
+ if op.offset is not None:
+ while asm[asm_index][0] < op.offset:
+ asm_index += 1
+ end_index = asm_index
+ while asm[end_index][0] < end:
+ end_index += 1
+ op.asm = '\n'.join([asm[i][1] for i in range(asm_index, end_index)])
+ return loop
+
+ def _asm_disassemble(self, d, origin_addr, tp):
+ from pypy.jit.backend.x86.tool.viewcode import machine_code_dump
+ return list(machine_code_dump(d, tp, origin_addr))
+
@classmethod
- def parse_from_input(cls, input):
- return cls(input, None, {}, 'lltype', None,
- nonstrict=True).parse()
+ def parse_from_input(cls, input, **kwds):
+ parser = cls(input, None, {}, 'lltype', None,
+ nonstrict=True)
+ loop = parser.parse()
+ return parser.postprocess(loop, **kwds)
def parse_args(self, opname, argspec):
if not argspec.strip():
@@ -284,3 +330,33 @@
res.append(op)
i += 1
return res
+
+
+def import_log(logname, ParserCls=SimpleParser):
+ log = parse_log_file(logname)
+ addrs = {}
+ for entry in extract_category(log, 'jit-backend-addr'):
+ m = re.search('bootstrap ([\da-f]+)', entry)
+ name = entry[:entry.find('(') - 1]
+ addrs[int(m.group(1), 16)] = name
+ dumps = {}
+ for entry in extract_category(log, 'jit-backend-dump'):
+ backend, _, dump, _ = entry.split("\n")
+ _, addr, _, data = re.split(" +", dump)
+ backend_name = backend.split(" ")[1]
+ addr = int(addr[1:], 16)
+ if addr in addrs:
+ dumps[addrs[addr]] = (backend_name, addr, data)
+ loops = []
+ for entry in extract_category(log, 'jit-log-opt'):
+ parser = ParserCls(entry, None, {}, 'lltype', None,
+ nonstrict=True)
+ loop = parser.parse()
+ comm = loop.comment
+ name = comm[2:comm.find(':')-1]
+ if name in dumps:
+ bname, start_ofs, dump = dumps[name]
+ parser.postprocess(loop, backend_tp=bname, backend_dump=dump,
+ dump_start=start_ofs)
+ loops.append(loop)
+ return log, loops
diff --git a/pypy/tool/jitlogparser/test/logtest.log b/pypy/tool/jitlogparser/test/logtest.log
new file mode 100644
--- /dev/null
+++ b/pypy/tool/jitlogparser/test/logtest.log
@@ -0,0 +1,38 @@
+[11f210b47027] {jit-backend
+[11f210b900f7] {jit-backend-dump
+BACKEND x86_64
+SYS_EXECUTABLE python
+CODE_DUMP @7f3b0b2e63d5 +0 554889E5534154415541564157488DA500000000488B042590C5540148C7042590C554010000000048898570FFFFFF488B042598C5540148C7042598C554010000000048898568FFFFFF488B0425A0C5540148C70425A0C554010000000048898560FFFFFF488B0425A8C5540148C70425A8C554010000000048898558FFFFFF4C8B3C2550525B0149BB3050920D3B7F00004D8B334983C60149BB3050920D3B7F00004D89334981FF102700000F8D000000004983C7014C8B342580F76A024983EE014C89342580F76A024983FE000F8C00000000E9AEFFFFFF488B042588F76A024829E0483B042580EC3C01760D49BB05632E0B3B7F000041FFD3554889E5534154415541564157488DA550FFFFFF4889BD70FFFFFF4889B568FFFFFF48899560FFFFFF48898D58FFFFFF4D89C7E954FFFFFF49BB00602E0B3B7F000041FFD34440484C3D030300000049BB00602E0B3B7F000041FFD34440484C3D070304000000
+[11f210b949b3] jit-backend-dump}
+[11f210b949b4] {jit-backend-addr
+Loop 0 (<code object f, file 'x.py', line 2> #9 LOAD_FAST) has address 7f3b0b2e645d to 7f3b0b2e64af (bootstrap 7f3b0b2e63d5)
+[11f210bab188] jit-backend-addr}
+[11f210bab189] jit-backend}
+[11f210bacbb7] {jit-log-opt-loop
+# Loop 0 : loop with 19 ops
+[p0, p1, p2, p3, i4]
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #9 LOAD_FAST')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #12 LOAD_CONST')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #15 COMPARE_OP')
++166: i6 = int_lt(i4, 10000)
+guard_true(i6, descr=<Guard3>) [p1, p0, p2, p3, i4]
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #18 POP_JUMP_IF_FALSE')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #21 LOAD_FAST')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #24 LOAD_CONST')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #27 INPLACE_ADD')
++179: i8 = int_add(i4, 1)
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #28 STORE_FAST')
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #31 JUMP_ABSOLUTE')
++183: i10 = getfield_raw(40564608, descr=<SignedFieldDescr pypysig_long_struct.c_value 0>)
++191: i12 = int_sub(i10, 1)
++195: setfield_raw(40564608, i12, descr=<SignedFieldDescr pypysig_long_struct.c_value 0>)
++203: i14 = int_lt(i12, 0)
+guard_false(i14, descr=<Guard4>) [p1, p0, p2, p3, i8, None]
+debug_merge_point(0, '<code object f. file 'x.py'. line 2> #9 LOAD_FAST')
++213: jump(p0, p1, p2, p3, i8, descr=<Loop0>)
++218: --end of the loop--
+[11f210c17981] jit-log-opt-loop}
+[11f210fb1d21] {jit-backend-counts
+0:8965
+1:2
+[11f210fb381b] jit-backend-counts}
diff --git a/pypy/tool/jitlogparser/test/test_parser.py b/pypy/tool/jitlogparser/test/test_parser.py
--- a/pypy/tool/jitlogparser/test/test_parser.py
+++ b/pypy/tool/jitlogparser/test/test_parser.py
@@ -1,12 +1,11 @@
-from pypy.jit.metainterp.resoperation import ResOperation, rop
-from pypy.jit.metainterp.history import ConstInt, Const
-from pypy.tool.jitlogparser.parser import SimpleParser, TraceForOpcode, Function,\
- adjust_bridges
+from pypy.tool.jitlogparser.parser import (SimpleParser, TraceForOpcode,
+ Function, adjust_bridges,
+ import_log)
from pypy.tool.jitlogparser.storage import LoopStorage
-import py
+import py, sys
-def parse(input):
- return SimpleParser.parse_from_input(input)
+def parse(input, **kwds):
+ return SimpleParser.parse_from_input(input, **kwds)
def test_parse():
@@ -111,6 +110,8 @@
assert res.chunks[1].lineno == 3
def test_linerange():
+ if sys.version_info > (2, 6):
+ py.test.skip("unportable test")
fname = str(py.path.local(__file__).join('..', 'x.py'))
ops = parse('''
[i0, i1]
@@ -125,6 +126,8 @@
assert res.lineset == set([7, 8, 9])
def test_linerange_notstarts():
+ if sys.version_info > (2, 6):
+ py.test.skip("unportable test")
fname = str(py.path.local(__file__).join('..', 'x.py'))
ops = parse("""
[p6, p1]
@@ -179,3 +182,35 @@
ops = Function.from_operations(loop.operations, LoopStorage())
chunk = ops.chunks[0]
assert chunk.bytecode_name == 'StrLiteralSearch'
+
+def test_parsing_assembler():
+ backend_dump = "554889E5534154415541564157488DA500000000488B042590C5540148C7042590C554010000000048898570FFFFFF488B042598C5540148C7042598C554010000000048898568FFFFFF488B0425A0C5540148C70425A0C554010000000048898560FFFFFF488B0425A8C5540148C70425A8C554010000000048898558FFFFFF4C8B3C2550525B0149BB30E06C96FC7F00004D8B334983C60149BB30E06C96FC7F00004D89334981FF102700000F8D000000004983C7014C8B342580F76A024983EE014C89342580F76A024983FE000F8C00000000E9AEFFFFFF488B042588F76A024829E0483B042580EC3C01760D49BB05F30894FC7F000041FFD3554889E5534154415541564157488DA550FFFFFF4889BD70FFFFFF4889B568FFFFFF48899560FFFFFF48898D58FFFFFF4D89C7E954FFFFFF49BB00F00894FC7F000041FFD34440484C3D030300000049BB00F00894FC7F000041FFD34440484C3D070304000000"
+ dump_start = 0x7f3b0b2e63d5
+ loop = parse("""
+ # Loop 0 : loop with 19 ops
+ [p0, p1, p2, p3, i4]
+ debug_merge_point(0, '<code object f. file 'x.py'. line 2> #15 COMPARE_OP')
+ +166: i6 = int_lt(i4, 10000)
+ guard_true(i6, descr=<Guard3>) [p1, p0, p2, p3, i4]
+ debug_merge_point(0, '<code object f. file 'x.py'. line 2> #27 INPLACE_ADD')
+ +179: i8 = int_add(i4, 1)
+ debug_merge_point(0, '<code object f. file 'x.py'. line 2> #31 JUMP_ABSOLUTE')
+ +183: i10 = getfield_raw(40564608, descr=<SignedFieldDescr pypysig_long_struct.c_value 0>)
+ +191: i12 = int_sub(i10, 1)
+ +195: setfield_raw(40564608, i12, descr=<SignedFieldDescr pypysig_long_struct.c_value 0>)
+ +203: i14 = int_lt(i12, 0)
+ guard_false(i14, descr=<Guard4>) [p1, p0, p2, p3, i8, None]
+ debug_merge_point(0, '<code object f. file 'x.py'. line 2> #9 LOAD_FAST')
+ +213: jump(p0, p1, p2, p3, i8, descr=<Loop0>)
+ +218: --end of the loop--""", backend_dump=backend_dump,
+ dump_start=dump_start,
+ backend_tp='x86_64')
+ cmp = loop.operations[1]
+ assert 'jge' in cmp.asm
+ assert '0x2710' in cmp.asm
+ assert 'jmp' in loop.operations[-1].asm
+
+def test_import_log():
+ _, loops = import_log(str(py.path.local(__file__).join('..',
+ 'logtest.log')))
+ assert 'jge' in loops[0].operations[3].asm
diff --git a/pypy/tool/pytest/appsupport.py b/pypy/tool/pytest/appsupport.py
--- a/pypy/tool/pytest/appsupport.py
+++ b/pypy/tool/pytest/appsupport.py
@@ -83,7 +83,7 @@
def __init__(self, space, operr):
self.space = space
self.operr = operr
- self.typename = operr.w_type.getname(space, "?")
+ self.typename = operr.w_type.getname(space)
self.traceback = AppTraceback(space, self.operr.get_traceback())
debug_excs = getattr(operr, 'debug_excs', [])
if debug_excs:
diff --git a/pypy/translator/goal/app_main.py b/pypy/translator/goal/app_main.py
--- a/pypy/translator/goal/app_main.py
+++ b/pypy/translator/goal/app_main.py
@@ -143,6 +143,7 @@
for key, value in items:
print ' --jit %s=N %slow-level JIT parameter (default %s)' % (
key, ' '*(18-len(key)), value)
+ print ' --jit off turn off the JIT'
def print_version(*args):
print "Python", sys.version
diff --git a/pypy/translator/goal/translate.py b/pypy/translator/goal/translate.py
--- a/pypy/translator/goal/translate.py
+++ b/pypy/translator/goal/translate.py
@@ -186,7 +186,7 @@
print "\n\nTarget specific help:\n\n"
targetspec_dic['print_help'](config)
print "\n\nFor detailed descriptions of the command line options see"
- print "http://codespeak.net/pypy/dist/pypy/doc/config/commandline.html"
+ print "http://pypy.readthedocs.org/en/latest/config/commandline.html"
sys.exit(0)
return targetspec_dic, translateconfig, config, args
diff --git a/pypy/translator/jvm/opcodes.py b/pypy/translator/jvm/opcodes.py
--- a/pypy/translator/jvm/opcodes.py
+++ b/pypy/translator/jvm/opcodes.py
@@ -98,6 +98,7 @@
'jit_marker': Ignore,
'jit_force_virtualizable': Ignore,
'jit_force_virtual': DoNothing,
+ 'jit_force_quasi_immutable': Ignore,
'debug_assert': [], # TODO: implement?
'debug_start_traceback': Ignore,
diff --git a/pypy/translator/jvm/src/pypy/PyPy.java b/pypy/translator/jvm/src/pypy/PyPy.java
--- a/pypy/translator/jvm/src/pypy/PyPy.java
+++ b/pypy/translator/jvm/src/pypy/PyPy.java
@@ -964,12 +964,15 @@
return a + File.separator + b;
}
- public String ll_strtod_formatd(String format, double d)
+ public String ll_strtod_formatd(double d, char code, int precision, int flags)
{
// XXX: this is really a quick hack to make things work.
// it should disappear, because this function is not
// supported by ootypesystem.
- return Double.toString(d); // XXX: we are ignoring "format"
+ DecimalFormat format = new DecimalFormat("0.###");
+ format.setMinimumFractionDigits(precision);
+ format.setMaximumFractionDigits(precision);
+ return format.format(d);
}
// ----------------------------------------------------------------------
diff --git a/pypy/translator/jvm/test/test_float.py b/pypy/translator/jvm/test/test_float.py
--- a/pypy/translator/jvm/test/test_float.py
+++ b/pypy/translator/jvm/test/test_float.py
@@ -22,3 +22,14 @@
def test_r_singlefloat(self):
py.test.skip("not implemented: single-precision floats")
+
+ def test_format_float(self):
+ from pypy.rlib.rfloat import _formatd
+ def fn(precision):
+ return _formatd(10.01, 'd', precision, 0)
+
+ res = self.interpret(fn, [2])
+ assert res == "10.01"
+
+ res = self.interpret(fn, [1])
+ assert res == "10.0"
More information about the pypy-commit
mailing list