Author: Richard Plangger <planri...@gmail.com>
Branch: py3.5-ssl
Changeset: r88788:c75ec5f968ae
Date: 2016-12-01 12:51 +0100
http://bitbucket.org/pypy/pypy/changeset/c75ec5f968ae/
Log: merge py3.5
diff --git a/lib-python/3/distutils/sysconfig_pypy.py
b/lib-python/3/distutils/sysconfig_pypy.py
--- a/lib-python/3/distutils/sysconfig_pypy.py
+++ b/lib-python/3/distutils/sysconfig_pypy.py
@@ -60,6 +60,8 @@
def _init_posix():
"""Initialize the module as appropriate for POSIX systems."""
+ so_list = [s[0] for s in imp.get_suffixes() if s[2] == imp.C_EXTENSION]
+ so_ext = (so_list or ['.so'])[0]
g = {}
g['CC'] = "gcc -pthread"
g['CXX'] = "g++ -pthread"
@@ -67,7 +69,7 @@
g['CFLAGS'] = "-DNDEBUG -O2"
g['CCSHARED'] = "-fPIC"
g['LDSHARED'] = "gcc -pthread -shared"
- g['SO'] = [s[0] for s in imp.get_suffixes() if s[2] == imp.C_EXTENSION][0]
+ g['SO'] = so_ext
g['SHLIB_SUFFIX'] = g['SO']
g['AR'] = "ar"
g['ARFLAGS'] = "rc"
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -192,6 +192,14 @@
assert self._finalize_.im_func is not W_Root._finalize_.im_func
space.finalizer_queue.register_finalizer(self)
+ def may_unregister_rpython_finalizer(self, space):
+ """Optimization hint only: if there is no user-defined __del__()
+ method, pass the hint ``don't call any finalizer'' to rgc.
+ """
+ if not self.getclass(space).hasuserdel:
+ from rpython.rlib import rgc
+ rgc.may_ignore_finalizer(self)
+
# hooks that the mapdict implementations needs:
def _get_mapdict_map(self):
return None
diff --git a/pypy/interpreter/generator.py b/pypy/interpreter/generator.py
--- a/pypy/interpreter/generator.py
+++ b/pypy/interpreter/generator.py
@@ -3,7 +3,7 @@
from pypy.interpreter.pyopcode import LoopBlock, SApplicationException, Yield
from pypy.interpreter.pycode import CO_YIELD_INSIDE_TRY
from pypy.interpreter.astcompiler import consts
-from rpython.rlib import jit
+from rpython.rlib import jit, rgc
from rpython.rlib.objectmodel import specialize
from rpython.rlib.rarithmetic import r_uint
@@ -20,7 +20,7 @@
self.running = False
self._name = name # may be null, use get_name()
self._qualname = qualname # may be null, use get_qualname()
- if (isinstance(self, Coroutine) # XXX would be cool not to need this
+ if (isinstance(self, Coroutine)
or self.pycode.co_flags & CO_YIELD_INSIDE_TRY):
self.register_finalizer(self.space)
self.saved_operr = None
@@ -89,7 +89,7 @@
# if the frame is now marked as finished, it was RETURNed from
if frame.frame_finished_execution:
- self.frame = None
+ self.frame_is_finished()
if space.is_w(w_result, space.w_None):
raise OperationError(space.w_StopIteration, space.w_None)
else:
@@ -107,6 +107,14 @@
if self.saved_operr is not None:
ec.set_sys_exc_info(self.saved_operr)
self.saved_operr = None
+ #
+ # Optimization only: after we've started a Coroutine without
+ # CO_YIELD_INSIDE_TRY, then Coroutine._finalize_() will be a no-op
+ if (isinstance(self, Coroutine)
+ and frame.last_instr == -1
+ and not (self.pycode.co_flags & CO_YIELD_INSIDE_TRY)):
+ rgc.may_ignore_finalizer(self)
+ #
self.running = True
try:
w_result = frame.execute_frame(self, w_arg_or_err)
@@ -116,7 +124,7 @@
if e.match(space, space.w_StopIteration):
self._leak_stopiteration(e)
finally:
- self.frame = None
+ self.frame_is_finished()
raise
finally:
frame.f_backref = jit.vref_None
@@ -323,6 +331,10 @@
break
block = block.previous
+ def frame_is_finished(self):
+ self.frame = None
+ rgc.may_ignore_finalizer(self)
+
class GeneratorIterator(GeneratorOrCoroutine):
"An iterator created by a generator."
@@ -364,7 +376,7 @@
break
# if the frame is now marked as finished, it was RETURNed from
if frame.frame_finished_execution:
- self.frame = None
+ self.frame_is_finished()
break
results.append(w_result) # YIELDed
return unpack_into
diff --git a/pypy/interpreter/module.py b/pypy/interpreter/module.py
--- a/pypy/interpreter/module.py
+++ b/pypy/interpreter/module.py
@@ -121,31 +121,8 @@
return space.newtuple(tup_return)
def descr_module__repr__(self, space):
- w_loader = space.finditem(self.w_dict, space.wrap('__loader__'))
- if w_loader is not None:
- try:
- return space.call_method(w_loader, "module_repr", self)
- except OperationError:
- pass
- try:
- w_name = space.getattr(self, space.wrap('__name__'))
- name = space.unicode_w(space.repr(w_name))
- except OperationError:
- name = u"'?'"
-
- try:
- w___file__ = space.getattr(self, space.wrap('__file__'))
- except OperationError:
- w___file__ = space.w_None
- if not space.isinstance_w(w___file__, space.w_unicode):
- if w_loader is not None:
- w_loader_repr = space.unicode_w(space.repr(w_loader))
- return space.wrap(u"<module %s (%s)>" % (name, w_loader_repr))
- else:
- return space.wrap(u"<module %s>" % (name,))
- else:
- __file__ = space.unicode_w(space.repr(w___file__))
- return space.wrap(u"<module %s from %s>" % (name, __file__))
+ w_importlib = space.getbuiltinmodule('_frozen_importlib')
+ return space.call_method(w_importlib, "_module_repr", self)
def descr_getattribute(self, space, w_attr):
from pypy.objspace.descroperation import object_getattribute
diff --git a/pypy/interpreter/test/test_module.py
b/pypy/interpreter/test/test_module.py
--- a/pypy/interpreter/test/test_module.py
+++ b/pypy/interpreter/test/test_module.py
@@ -129,6 +129,20 @@
expected_repr = "<module 'test_module' ({})>".format(loader_repr)
assert mod_repr == expected_repr
+ def test_repr_with_loader_with_raising_module_repr2(self):
+ import sys
+ test_module = type(sys)("test_module", "doc")
+ # If an exception occurs in module_repr(), the exception is caught
+ # and discarded, and the calculation of the module’s repr
continues
+ # as if module_repr() did not exist.
+ class CustomLoaderWithRaisingRepr:
+ @classmethod
+ def module_repr(cls, module):
+ raise KeyboardInterrupt
+
+ test_module.__loader__ = CustomLoaderWithRaisingRepr
+ raises(KeyboardInterrupt, 'repr(test_module)')
+
def test_repr_with_raising_loader_and___file__(self):
import sys
test_module = type(sys)("test_module", "doc")
diff --git a/pypy/module/__builtin__/descriptor.py
b/pypy/module/__builtin__/descriptor.py
--- a/pypy/module/__builtin__/descriptor.py
+++ b/pypy/module/__builtin__/descriptor.py
@@ -1,3 +1,4 @@
+from rpython.rlib import jit
from pypy.interpreter.baseobjspace import W_Root
from pypy.interpreter.error import OperationError, oefmt
from pypy.interpreter.gateway import WrappedDefault, interp2app, unwrap_spec
@@ -67,29 +68,43 @@
# fallback to object.__getattribute__()
return space.call_function(object_getattribute(space), self, w_name)
-def _super_from_frame(space, frame):
- """super() without args -- fill in from __class__ and first local
- variable on the stack.
- """
- code = frame.pycode
- if not code:
- raise oefmt(space.w_RuntimeError, "super(): no code object")
+@jit.elidable
+def _get_self_location(space, code):
if code.co_argcount == 0:
raise oefmt(space.w_RuntimeError, "super(): no arguments")
- w_obj = frame.locals_cells_stack_w[0]
- if not w_obj:
- raise oefmt(space.w_RuntimeError, "super(): arg[0] deleted")
+ args_to_copy = code._args_as_cellvars
+ for i in range(len(args_to_copy)):
+ if args_to_copy[i] == 0:
+ self_cell = i
+ break
+ else:
+ self_cell = -1
for index, name in enumerate(code.co_freevars):
if name == '__class__':
break
else:
raise oefmt(space.w_RuntimeError, "super(): __class__ cell not found")
+ class_cell = len(code.co_cellvars) + index
+ return self_cell, class_cell
+
+def _super_from_frame(space, frame):
+ """super() without args -- fill in from __class__ and first local
+ variable on the stack.
+ """
+ if frame is None:
+ raise oefmt(space.w_RuntimeError, "super(): no frame object")
+ self_cell, class_cell = _get_self_location(space, frame.getcode())
+ if self_cell < 0:
+ w_obj = frame.locals_cells_stack_w[0]
+ else:
+ w_obj = frame._getcell(self_cell).w_value
+ if not w_obj:
+ raise oefmt(space.w_RuntimeError, "super(): arg[0] deleted")
+
# a kind of LOAD_DEREF
- cell = frame._getcell(len(code.co_cellvars) + index)
- try:
- w_starttype = cell.get()
- except ValueError:
+ w_starttype = frame._getcell(class_cell).w_value
+ if w_starttype is None:
raise oefmt(space.w_RuntimeError, "super(): empty __class__ cell")
return w_starttype, w_obj
diff --git a/pypy/module/__builtin__/test/test_descriptor.py
b/pypy/module/__builtin__/test/test_descriptor.py
--- a/pypy/module/__builtin__/test/test_descriptor.py
+++ b/pypy/module/__builtin__/test/test_descriptor.py
@@ -508,4 +508,15 @@
del __class__
super()
raises(RuntimeError, X().f)
+ class X:
+ def f(self):
+ def g():
+ print(self) # make 'self' a closure inside 'f'
+ del self
+ super()
+ raises(RuntimeError, X().f)
+ class X:
+ def f(*args):
+ super()
+ raises(RuntimeError, X().f)
"""
diff --git a/pypy/module/_cffi_backend/cdataobj.py
b/pypy/module/_cffi_backend/cdataobj.py
--- a/pypy/module/_cffi_backend/cdataobj.py
+++ b/pypy/module/_cffi_backend/cdataobj.py
@@ -397,7 +397,7 @@
space = self.space
if space.is_none(w_destructor):
if isinstance(self, W_CDataGCP):
- self.w_destructor = None
+ self.detach_destructor()
return space.w_None
raise oefmt(space.w_TypeError,
"Can remove destructor only on a object "
@@ -604,6 +604,10 @@
self.w_destructor = None
self.space.call_function(w_destructor, self.w_original_cdata)
+ def detach_destructor(self):
+ self.w_destructor = None
+ self.may_unregister_rpython_finalizer(self.space)
+
W_CData.typedef = TypeDef(
'_cffi_backend.CData',
diff --git a/pypy/module/_cffi_backend/cdlopen.py
b/pypy/module/_cffi_backend/cdlopen.py
--- a/pypy/module/_cffi_backend/cdlopen.py
+++ b/pypy/module/_cffi_backend/cdlopen.py
@@ -55,6 +55,7 @@
if not libhandle:
raise oefmt(self.ffi.w_FFIError, "library '%s' is already closed",
self.libname)
+ self.may_unregister_rpython_finalizer(self.ffi.space)
# Clear the dict to force further accesses to do cdlopen_fetch()
# again, and fail because the library was closed. Note that the
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
@@ -63,15 +63,47 @@
raise NotImplementedError
def read_w(self, space, w_size=None):
+ """Read and return up to n bytes.
+
+If the argument is omitted, None, or negative, reads and
+returns all data until EOF.
+
+If the argument is positive, and the underlying raw stream is
+not 'interactive', multiple raw reads may be issued to satisfy
+the byte count (unless EOF is reached first). But for
+interactive raw streams (as well as sockets and pipes), at most
+one raw read will be issued, and a short result does not imply
+that EOF is imminent.
+
+Returns an empty bytes object on EOF.
+
+Returns None if the underlying raw stream was open in non-blocking
+mode and no data is available at the moment."""
self._unsupportedoperation(space, "read")
def read1_w(self, space, w_size):
+ """Read and return up to n bytes, with at most one read() call
+to the underlying raw stream. A short result does not imply
+that EOF is imminent.
+
+Returns an empty bytes object on EOF."""
self._unsupportedoperation(space, "read1")
def write_w(self, space, w_data):
+ """Write the given buffer to the IO stream.
+
+Returns the number of bytes written, which is always the length of b
+in bytes.
+
+Raises BlockingIOError if the buffer is full and the
+underlying raw stream cannot accept more data at the moment."""
self._unsupportedoperation(space, "write")
def detach_w(self, space):
+ """Disconnect this buffer from its underlying raw stream and return it.
+
+After the raw stream has been detached, the buffer is in an unusable
+state."""
self._unsupportedoperation(space, "detach")
def readinto_w(self, space, w_buffer):
@@ -92,6 +124,20 @@
W_BufferedIOBase.typedef = TypeDef(
'_io._BufferedIOBase', W_IOBase.typedef,
+ __doc__="""Base class for buffered IO objects.
+
+The main difference with RawIOBase is that the read() method
+supports omitting the size argument, and does not have a default
+implementation that defers to readinto().
+
+In addition, read(), readinto() and write() may raise
+BlockingIOError if the underlying raw stream is in non-blocking
+mode and not ready; unlike their raw counterparts, they will never
+return None.
+
+A typical implementation should not inherit from a RawIOBase
+implementation, but wrap one.
+""",
__new__ = generic_new_descr(W_BufferedIOBase),
read = interp2app(W_BufferedIOBase.read_w),
read1 = interp2app(W_BufferedIOBase.read1_w),
@@ -112,6 +158,9 @@
def getlength(self):
return self.length
+ def getitem(self, index):
+ return self.buf[index]
+
def setitem(self, index, char):
self.buf[self.start + index] = char
diff --git a/pypy/module/_io/test/test_bufferedio.py
b/pypy/module/_io/test/test_bufferedio.py
--- a/pypy/module/_io/test/test_bufferedio.py
+++ b/pypy/module/_io/test/test_bufferedio.py
@@ -65,6 +65,23 @@
bufio = _io.BufferedReader(MockIO())
assert bufio.read(9000) == b"abcdefg"
+ def test_valid_buffer(self):
+ import _io
+
+ class MockIO(_io._IOBase):
+ def readable(self):
+ return True
+
+ def readinto(self, buf):
+ # Check that `buf` is a valid memoryview object
+ assert buf.itemsize == 1
+ assert buf.strides == (1,)
+ assert buf.shape == (len(buf),)
+ return len(bytes(buf))
+
+ bufio = _io.BufferedReader(MockIO())
+ assert len(bufio.read(5)) == 5 # Note: PyPy zeros the buffer, CPython
does not
+
def test_buffering(self):
import _io
data = b"abcdefghi"
@@ -695,7 +712,7 @@
expected[j] = 2
expected[i] = 1
assert raw.getvalue() == expected
-
+
def test_interleaved_read_write(self):
import _io as io
# Test for issue #12213
diff --git a/pypy/module/_socket/interp_socket.py
b/pypy/module/_socket/interp_socket.py
--- a/pypy/module/_socket/interp_socket.py
+++ b/pypy/module/_socket/interp_socket.py
@@ -216,7 +216,7 @@
def descr_repr(self, space):
fd = intmask(self.sock.fd) # Force to signed type even on Windows.
return space.wrap("<socket object, fd=%d, family=%d,"
- " type=%d, protocol=%d>" %
+ " type=%d, proto=%d>" %
(fd, self.sock.family,
self.sock.type, self.sock.proto))
@@ -266,6 +266,7 @@
except SocketError:
# cpython doesn't return any errors on close
pass
+ self.may_unregister_rpython_finalizer(space)
def connect_w(self, space, w_addr):
"""connect(address)
diff --git a/pypy/module/_socket/test/test_sock_app.py
b/pypy/module/_socket/test/test_sock_app.py
--- a/pypy/module/_socket/test/test_sock_app.py
+++ b/pypy/module/_socket/test/test_sock_app.py
@@ -373,12 +373,12 @@
import _socket
s = _socket.socket(_socket.AF_INET, _socket.SOCK_STREAM)
try:
- expected = ('<socket object, fd=%s, family=%s, type=%s,
protocol=%s>'
+ expected = ('<socket object, fd=%s, family=%s, type=%s, proto=%s>'
% (s.fileno(), s.family, s.type, s.proto))
assert repr(s) == expected
finally:
s.close()
- expected = ('<socket object, fd=-1, family=%s, type=%s, protocol=%s>'
+ expected = ('<socket object, fd=-1, family=%s, type=%s, proto=%s>'
% (s.family, s.type, s.proto))
assert repr(s) == expected
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
@@ -218,7 +218,7 @@
return self.space.w_None
return w_obj
- def descr__eq__(self, space, w_ref2):
+ def compare(self, space, w_ref2, invert):
if not isinstance(w_ref2, W_Weakref):
return space.w_NotImplemented
ref1 = self
@@ -226,11 +226,18 @@
w_obj1 = ref1.dereference()
w_obj2 = ref2.dereference()
if w_obj1 is None or w_obj2 is None:
- return space.is_(ref1, ref2)
- return space.eq(w_obj1, w_obj2)
+ w_res = space.is_(ref1, ref2)
+ else:
+ w_res = space.eq(w_obj1, w_obj2)
+ if invert:
+ w_res = space.not_(w_res)
+ return w_res
+
+ def descr__eq__(self, space, w_ref2):
+ return self.compare(space, w_ref2, invert=False)
def descr__ne__(self, space, w_ref2):
- return space.not_(space.eq(self, w_ref2))
+ return self.compare(space, w_ref2, invert=True)
def descr_callback(self, space):
return self.w_callable
diff --git a/pypy/module/_weakref/test/test_weakref.py
b/pypy/module/_weakref/test/test_weakref.py
--- a/pypy/module/_weakref/test/test_weakref.py
+++ b/pypy/module/_weakref/test/test_weakref.py
@@ -153,6 +153,14 @@
assert not (ref1 == [])
assert ref1 != []
+ def test_ne(self):
+ import _weakref
+ class X(object):
+ pass
+ ref1 = _weakref.ref(X())
+ assert ref1.__eq__(X()) is NotImplemented
+ assert ref1.__ne__(X()) is NotImplemented
+
def test_getweakrefs(self):
import _weakref, gc
class A(object):
diff --git a/pypy/module/pypyjit/test_pypy_c/test_ffi.py
b/pypy/module/pypyjit/test_pypy_c/test_ffi.py
--- a/pypy/module/pypyjit/test_pypy_c/test_ffi.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_ffi.py
@@ -272,11 +272,11 @@
_write = libc.load_function(BWrite, 'write')
i = 0
fd0, fd1 = os.pipe()
- buffer = _cffi_backend.newp(BCharP, 'A')
+ buffer = _cffi_backend.newp(BCharP, b'A')
while i < 300:
tmp = _write(fd1, buffer, 1) # ID: cfficall
assert tmp == 1
- assert os.read(fd0, 2) == 'A'
+ assert os.read(fd0, 2) == b'A'
i += 1
os.close(fd0)
os.close(fd1)
@@ -410,7 +410,7 @@
i161 = int_lt(i160, i43)
guard_true(i161, descr=...)
i162 = int_add(i160, 1)
- setfield_gc(p22, i162, descr=<FieldS
pypy.module.__builtin__.functional.W_XRangeIterator.inst_current .>)
+ setfield_gc(p22, i162, descr=<FieldS
pypy.module.__builtin__.functional.W_IntRangeIterator.inst_current .>)
guard_not_invalidated(descr=...)
p163 = force_token()
p164 = force_token()
diff --git a/pypy/module/pypyjit/test_pypy_c/test_globals.py
b/pypy/module/pypyjit/test_pypy_c/test_globals.py
--- a/pypy/module/pypyjit/test_pypy_c/test_globals.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_globals.py
@@ -16,5 +16,6 @@
assert log.result == 500
loop, = log.loops_by_filename(self.filepath)
assert loop.match_by_id("loadglobal", """
+ p1 = getfield_gc_r(..., descr=...) # dead
guard_not_invalidated(descr=...)
""")
diff --git a/pypy/module/pypyjit/test_pypy_c/test_instance.py
b/pypy/module/pypyjit/test_pypy_c/test_instance.py
--- a/pypy/module/pypyjit/test_pypy_c/test_instance.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_instance.py
@@ -320,3 +320,36 @@
--TICK--
jump(..., descr=...)
""")
+
+ def test_super_no_args(self):
+ def main():
+ class A(object):
+ def m(self, x):
+ return x + 1
+ class B(A):
+ def m(self, x):
+ return super().m(x)
+ i = 0
+ while i < 300:
+ i = B().m(i)
+ return i
+
+ log = self.run(main, [])
+ loop, = log.loops_by_filename(self.filepath)
+ assert loop.match("""
+ i78 = int_lt(i72, 300)
+ guard_true(i78, descr=...)
+ guard_not_invalidated(descr=...)
+ p1 = force_token()
+ p65 = force_token()
+ p3 = force_token()
+ i81 = int_add(i72, 1)
+
+ # can't use TICK here, because of the extra setfield_gc
+ ticker0 = getfield_raw_i(#, descr=<FieldS
pypysig_long_struct.c_value .*>)
+ setfield_gc(p0, p65, descr=<FieldP
pypy.interpreter.pyframe.PyFrame.vable_token .>)
+ ticker_cond0 = int_lt(ticker0, 0)
+ guard_false(ticker_cond0, descr=...)
+
+ jump(..., descr=...)
+ """)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_min_max.py
b/pypy/module/pypyjit/test_pypy_c/test_min_max.py
--- a/pypy/module/pypyjit/test_pypy_c/test_min_max.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_min_max.py
@@ -38,7 +38,7 @@
loop, = log.loops_by_filename(self.filepath)
assert loop.match("""
...
- p76 = call_assembler_r(_, _, _, _, descr=...)
+ p76 = call_assembler_r(..., descr=...)
...
""")
loop2 = log.loops[0]
@@ -79,6 +79,6 @@
assert len(guards) < 20
assert loop.match("""
...
- p76 = call_assembler_r(_, _, _, _, descr=...)
+ p76 = call_assembler_r(..., descr=...)
...
""")
diff --git a/pypy/module/pypyjit/test_pypy_c/test_misc.py
b/pypy/module/pypyjit/test_pypy_c/test_misc.py
--- a/pypy/module/pypyjit/test_pypy_c/test_misc.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_misc.py
@@ -247,6 +247,13 @@
""")
def test_dont_trace_every_iteration(self):
+ def reference(a, b):
+ i = sa = 0
+ while i < 300:
+ sa += a % b
+ i += 1
+ return sa
+ #
def main(a, b):
i = sa = 0
while i < 300:
@@ -258,9 +265,12 @@
i += 1
return sa
#
+ log_ref = self.run(reference, [10, 20])
+ assert log_ref.result == 300 * (10 % 20)
+ #
log = self.run(main, [10, 20])
assert log.result == 300 * (10 % 20)
- assert log.jit_summary.tracing_no == 1
+ assert log.jit_summary.tracing_no == log_ref.jit_summary.tracing_no
loop, = log.loops_by_filename(self.filepath)
assert loop.match("""
i11 = int_lt(i7, 300)
@@ -274,7 +284,7 @@
#
log = self.run(main, [-10, -20])
assert log.result == 300 * (-10 % -20)
- assert log.jit_summary.tracing_no == 1
+ assert log.jit_summary.tracing_no == log_ref.jit_summary.tracing_no
def test_overflow_checking(self):
"""
@@ -297,6 +307,7 @@
self.run_and_check(main, [])
def test_global(self):
+ # check that the global read is removed even from the entry bridge
log = self.run("""
i = 0
globalinc = 1
@@ -308,7 +319,10 @@
""", [1000])
loop, = log.loops_by_id("globalread", is_entry_bridge=True)
- assert len(loop.ops_by_id("globalread")) == 0
+ assert loop.match_by_id("globalread", """
+ # only a dead read
+ p26 = getfield_gc_r(ConstPtr(ptr25), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
+ """)
def test_eval(self):
def main():
@@ -349,7 +363,8 @@
def test_long_comparison(self):
def main(n):
while n:
- 12345L > 123L # ID: long_op
+ x = 12345678901234567890123456
+ x > 1231231231231231231231231 # ID: long_op
n -= 1
log = self.run(main, [300])
diff --git a/pypy/module/pypyjit/test_pypy_c/test_shift.py
b/pypy/module/pypyjit/test_pypy_c/test_shift.py
--- a/pypy/module/pypyjit/test_pypy_c/test_shift.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_shift.py
@@ -196,8 +196,7 @@
"""
from sys import maxint
- def main(a, b, c):
- from sys import maxint
+ def main(a, b, c, maxint):
i = sa = 0
while i < 300:
if 0 < a < 10: pass
@@ -210,9 +209,9 @@
sa += (b<<100)>>100
sa += (c<<100)>>100
i += 1
- return long(sa)
+ return sa
for a in (1, 4, 8, 100):
for b in (-10, 10, -201, 201, -maxint/3, maxint/3):
for c in (-10, 10, -maxint/3, maxint/3):
- yield self.run_and_check, main, [a, b, c]
+ yield self.run_and_check, main, [a, b, c, maxint]
diff --git a/pypy/module/pypyjit/test_pypy_c/test_string.py
b/pypy/module/pypyjit/test_pypy_c/test_string.py
--- a/pypy/module/pypyjit/test_pypy_c/test_string.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_string.py
@@ -5,50 +5,102 @@
class TestString(BaseTestPyPyC):
+
+ def test_python3_missing_bchr(self):
+ # Check that 'bytes([i])' is special-cased into something
+ # efficient, as Python 3.5 doesn't have a bchr() function or
+ # anything more direct.
+ def main(n):
+ i = 0
+ result = b''
+ while i < n:
+ c = bytes([i])
+ result += c
+ i += 1
+ return i
+ log = self.run(main, [255])
+ assert log.result == 255
+ loop, = log.loops_by_filename(self.filepath)
+ assert loop.match("""
+ # nothing left like allocating a list object or doing any
+ # residual call
+ i49 = int_lt(i38, i26)
+ guard_true(i49, descr=...)
+ guard_not_invalidated(descr=...)
+ i51 = int_lt(i38, 256)
+ guard_true(i51, descr=...)
+ i53 = int_add(i38, 1)
+ --TICK--
+ i58 = strlen(p46)
+ i60 = int_add(i58, 1)
+ p61 = newstr(i60)
+ copystrcontent(p46, p61, 0, 0, i58)
+ strsetitem(p61, i58, i38)
+ p62 = newstr(1)
+ strsetitem(p62, 0, i38)
+ jump(..., descr=...)
+ """)
+
def test_lookup_default_encoding(self):
def main(n):
- import string
i = 0
- letters = string.letters
- uletters = unicode(string.letters)
+ letters = b'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+ uletters = u'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
while i < n:
- i += letters[i % len(letters)] == uletters[i % len(letters)]
+ c = bytes([letters[i % len(uletters)]])
+ i += (c.decode() == uletters[i % len(uletters)])
return i
log = self.run(main, [300], import_site=True)
assert log.result == 300
loop, = log.loops_by_filename(self.filepath)
assert loop.match("""
- i14 = int_lt(i6, i9)
- guard_true(i14, descr=...)
+ i88 = int_lt(i83, i36)
+ guard_true(i88, descr=...)
+ p90 = getfield_gc_r(ConstPtr(ptr89), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
guard_not_invalidated(descr=...)
- i16 = int_eq(i6, %d)
- i19 = call_i(ConstClass(ll_int_py_mod__Signed_Signed), i6, i10,
descr=<Calli . ii EF=0 OS=14>)
- i21 = int_lt(i19, 0)
- guard_false(i21, descr=...)
- i22 = int_ge(i19, i10)
- guard_false(i22, descr=...)
- i23 = strgetitem(p11, i19)
- i24 = int_ge(i19, i12)
- guard_false(i24, descr=...)
- i25 = unicodegetitem(p13, i19)
- p27 = newstr(1)
- strsetitem(p27, 0, i23)
- p30 = call_r(ConstClass(ll_str2unicode__rpy_stringPtr), p27,
descr=...)
+ i92 = int_eq(i83, %d)
+ i94 = call_i(ConstClass(ll_int_py_mod__Signed_Signed), i83, i46,
descr=<Calli . ii EF=0 OS=14>)
+ i96 = int_lt(i94, 0)
+ guard_false(i96, descr=...)
+ i97 = int_ge(i94, i53)
+ guard_false(i97, descr=...)
+ i98 = strgetitem(p52, i94)
+ p100 = getfield_gc_r(ConstPtr(ptr99), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
+ p101 = force_token()
+ p103 = newstr(1)
+ strsetitem(p103, 0, i98)
+ p104 = new(descr=<SizeDescr ..?>)
+ p106 = newunicode(1)
+ setfield_gc(p0, p101, descr=<FieldP
pypy.interpreter.pyframe.PyFrame.vable_token .>)
+ setfield_gc(p104, p106, descr=<FieldP unicodebuilder.current_buf
..?>)
+ setfield_gc(p104, 0, descr=<FieldS unicodebuilder.current_pos ..?>)
+ setfield_gc(p104, 1, descr=<FieldS unicodebuilder.current_end ..?>)
+ setfield_gc(p104, 1, descr=<FieldS unicodebuilder.total_size 32>)
+ i113 = call_may_force_i(ConstClass(str_decode_utf_8_impl), p103,
1, ConstPtr(null), 1, 0, 0, p104, descr=<Calli . ririiir EF=7>)
+ guard_not_forced(descr=...)
guard_no_exception(descr=...)
- i32 =
call_i(ConstClass(_ll_2_str_eq_checknull_char__rpy_unicodePtr_UniChar), p30,
i25, descr=...)
- guard_true(i32, descr=...)
- i34 = int_add(i6, 1)
+ p116 =
call_r(ConstClass(ll_build_trampoline__v1351___simple_call__function_), p104,
descr=<Callr . r EF=5>)
+ guard_no_exception(descr=...)
+ guard_nonnull(p116, descr=...)
+ p118 = getfield_gc_r(ConstPtr(ptr117), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
+ guard_not_invalidated(descr=...)
+ i119 = int_ge(i94, i46)
+ guard_false(i119, descr=...)
+ i120 = unicodegetitem(p45, i94)
+ i122 =
call_i(ConstClass(_ll_2_str_eq_nonnull_char__rpy_unicodePtr_UniChar), p116,
i120, descr=<Calli . ri EF=0 OS=49>)
+ guard_true(i122, descr=...)
+ i124 = int_add(i83, 1)
--TICK--
jump(..., descr=...)
""" % (-sys.maxint-1,))
- def test_long(self):
+ def test_int_base_16(self):
def main(n):
- import string
i = 1
while i < n:
- i += int(long(string.digits[i % len(string.digits)], 16))
+ digits = '0123456789'
+ i += int(digits[i % len(digits)], 16)
return i
log = self.run(main, [1100], import_site=True)
@@ -61,7 +113,9 @@
assert loop.match("""
i11 = int_lt(i6, i7)
guard_true(i11, descr=...)
+ p70 = getfield_gc_r(ConstPtr(ptr69), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
guard_not_invalidated(descr=...)
+ p72 = getfield_gc_r(ConstPtr(ptr71), descr=<FieldP
pypy.objspace.std.unicodeobject.W_UnicodeObject.inst__utf8 .>)
i13 = int_eq(i6, %d) # value provided below
# "mod 10" block:
@@ -73,17 +127,20 @@
i87 = int_mul(i85, 10)
i19 = int_sub(i6, i87)
- i23 = strgetitem(p10, i19)
- p25 = newstr(1)
- strsetitem(p25, 0, i23)
- p93 = call_r(ConstClass(fromstr), p25, 16, descr=<Callr . ri EF=4>)
+ i23 = unicodegetitem(ConstPtr(ptr92), i19)
+ p25 = newunicode(1)
+ unicodesetitem(p25, 0, i23)
+ p97 = call_r(ConstClass(_rpy_unicode_to_decimal_w), p25,
descr=<Callr . r EF=5>)
guard_no_exception(descr=...)
- i95 = getfield_gc_i(p93, descr=<FieldS
rpython.rlib.rbigint.rbigint.inst_size .*>)
- i96 = int_gt(i95, #)
- guard_false(i96, descr=...)
- i94 = call_i(ConstClass(rbigint._toint_helper), p93, descr=<Calli
. r EF=4>)
+ i98 = unicodelen(p97)
+ p99 = force_token()
+ setfield_gc(p0, p99, descr=<FieldP
pypy.interpreter.pyframe.PyFrame.vable_token .>)
+ p104 = call_may_force_r(ConstClass(unicode_encode_utf_8_impl),
p97, i98, ConstPtr(ptr101), 1, 1, descr=<Callr . ririi EF=7>)
+ guard_not_forced(descr=...)
guard_no_exception(descr=...)
- i95 = int_add_ovf(i6, i94)
+ i107 = call_i(ConstClass(string_to_int), p104, 16, descr=<Calli .
ri EF=4>)
+ guard_no_exception(descr=...)
+ i95 = int_add_ovf(i6, i107)
guard_no_overflow(descr=...)
--TICK--
jump(..., descr=...)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_struct.py
b/pypy/module/pypyjit/test_pypy_c/test_struct.py
--- a/pypy/module/pypyjit/test_pypy_c/test_struct.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_struct.py
@@ -21,7 +21,7 @@
while i < n:
buf = struct.pack("<i", i) # ID: pack
x = struct.unpack("<i", buf)[0] # ID: unpack
- i += x / i
+ i += x // i
return i
log = self.run(main, [1000])
@@ -82,7 +82,7 @@
while i < n:
buf = s.pack(-1, i) # ID: pack
x = s.unpack(buf)[1] # ID: unpack
- i += x / i
+ i += x // i
return i
log = self.run(main, [1000])
diff --git a/pypy/module/select/interp_epoll.py
b/pypy/module/select/interp_epoll.py
--- a/pypy/module/select/interp_epoll.py
+++ b/pypy/module/select/interp_epoll.py
@@ -81,6 +81,7 @@
class W_Epoll(W_Root):
def __init__(self, space, epfd):
+ self.space = space
self.epfd = epfd
self.register_finalizer(space)
@@ -113,6 +114,7 @@
if not self.get_closed():
socketclose(self.epfd)
self.epfd = -1
+ self.may_unregister_rpython_finalizer(self.space)
def epoll_ctl(self, space, ctl, w_fd, eventmask, ignore_ebadf=False):
fd = space.c_filedescriptor_w(w_fd)
diff --git a/pypy/module/select/interp_kqueue.py
b/pypy/module/select/interp_kqueue.py
--- a/pypy/module/select/interp_kqueue.py
+++ b/pypy/module/select/interp_kqueue.py
@@ -109,6 +109,7 @@
class W_Kqueue(W_Root):
def __init__(self, space, kqfd):
+ self.space = space
self.kqfd = kqfd
self.register_finalizer(space)
@@ -137,6 +138,7 @@
kqfd = self.kqfd
self.kqfd = -1
socketclose_no_errno(kqfd)
+ self.may_unregister_rpython_finalizer(self.space)
def check_closed(self, space):
if self.get_closed():
diff --git a/pypy/module/signal/test/test_signal.py
b/pypy/module/signal/test/test_signal.py
--- a/pypy/module/signal/test/test_signal.py
+++ b/pypy/module/signal/test/test_signal.py
@@ -40,23 +40,22 @@
}
def setup_class(cls):
- cls.w_signal = cls.space.getbuiltinmodule('_signal')
cls.w_temppath = cls.space.wrap(
str(py.test.ensuretemp("signal").join("foo.txt")))
cls.w_appdirect = cls.space.wrap(cls.runappdirect)
def test_exported_names(self):
- import os
- self.signal.__dict__ # crashes if the interpleveldefs are invalid
+ import os, _signal
+ _signal.__dict__ # crashes if the interpleveldefs are invalid
if os.name == 'nt':
- assert self.signal.CTRL_BREAK_EVENT == 1
- assert self.signal.CTRL_C_EVENT == 0
+ assert _signal.CTRL_BREAK_EVENT == 1
+ assert _signal.CTRL_C_EVENT == 0
def test_basics(self):
- import types, os
+ import types, os, _signal
if not hasattr(os, 'kill') or not hasattr(os, 'getpid'):
skip("requires os.kill() and os.getpid()")
- signal = self.signal # the signal module to test
+ signal = _signal # the signal module to test
if not hasattr(signal, 'SIGUSR1'):
skip("requires SIGUSR1 in signal")
signum = signal.SIGUSR1
diff --git a/pypy/module/sys/app.py b/pypy/module/sys/app.py
--- a/pypy/module/sys/app.py
+++ b/pypy/module/sys/app.py
@@ -112,23 +112,35 @@
class SimpleNamespace:
+ """A simple attribute-based namespace.
+
+SimpleNamespace(**kwargs)"""
+
def __init__(self, **kwargs):
self.__dict__.update(kwargs)
- def __repr__(self, recurse=set()):
+ def __repr__(self):
ident = id(self)
- if ident in recurse:
+ if ident in sns_recurse:
return "namespace(...)"
- recurse.add(ident)
+ sns_recurse.add(ident)
try:
pairs = ('%s=%r' % item for item in sorted(self.__dict__.items()))
return "namespace(%s)" % ', '.join(pairs)
finally:
- recurse.remove(ident)
+ sns_recurse.discard(ident)
def __eq__(self, other):
- return (isinstance(other, SimpleNamespace) and
- self.__dict__ == other.__dict__)
+ if issubclass(type(other), SimpleNamespace):
+ return self.__dict__ == other.__dict__
+ return NotImplemented
+
+ def __ne__(self, other):
+ if issubclass(type(other), SimpleNamespace):
+ return self.__dict__ != other.__dict__
+ return NotImplemented
+
+sns_recurse = set()
# This class is not exposed in sys, but by the types module.
SimpleNamespace.__module__ = 'types'
diff --git a/pypy/module/sys/test/test_sysmodule.py
b/pypy/module/sys/test/test_sysmodule.py
--- a/pypy/module/sys/test/test_sysmodule.py
+++ b/pypy/module/sys/test/test_sysmodule.py
@@ -589,6 +589,35 @@
#
raises(AttributeError, "del ns.spam")
del ns.y
+ #
+ assert ns == SimpleNamespace(z=4, x=1, w=3)
+ assert (ns != SimpleNamespace(z=4, x=1, w=3)) is False
+ assert (ns == SimpleNamespace(z=4, x=2, w=3)) is False
+ assert ns != SimpleNamespace(z=4, x=2, w=3)
+ #
+ class Foo(SimpleNamespace):
+ pass
+ assert ns == Foo(z=4, x=1, w=3)
+ assert (ns != Foo(z=4, x=1, w=3)) is False
+ assert (ns == Foo(z=4, x=2, w=3)) is False
+ assert ns != Foo(z=4, x=2, w=3)
+ #
+ class Other:
+ def __init__(self, x, z, w):
+ self.x = x
+ self.z = z
+ self.w = w
+ assert (ns == Other(z=4, x=1, w=3)) is False
+ assert ns != Other(z=4, x=1, w=3)
+ assert (Foo(z=4, x=1, w=3) == Other(z=4, x=1, w=3)) is False
+ assert Foo(z=4, x=1, w=3) != Other(z=4, x=1, w=3)
+ #
+ class Fake:
+ __class__ = SimpleNamespace
+ assert isinstance(Fake(), SimpleNamespace)
+ assert not issubclass(Fake, SimpleNamespace)
+ assert (Fake() == SimpleNamespace()) is False
+ assert SimpleNamespace() != Fake()
def test_pickle_simplenamespace(self):
import pickle, sys
diff --git a/pypy/module/zlib/interp_zlib.py b/pypy/module/zlib/interp_zlib.py
--- a/pypy/module/zlib/interp_zlib.py
+++ b/pypy/module/zlib/interp_zlib.py
@@ -183,6 +183,7 @@
if mode == rzlib.Z_FINISH: # release the data structures now
rzlib.deflateEnd(self.stream)
self.stream = rzlib.null_stream
+ self.may_unregister_rpython_finalizer(space)
finally:
self.unlock()
except rzlib.RZlibError as e:
diff --git a/pypy/objspace/descroperation.py b/pypy/objspace/descroperation.py
--- a/pypy/objspace/descroperation.py
+++ b/pypy/objspace/descroperation.py
@@ -705,7 +705,7 @@
return w_result
raise oefmt(space.w_TypeError,
- "%(specialname)s returned non-%(targetname)s (type "
+ "%(specialname)s returned non-string (type "
"'%%T')", w_result)
assert not hasattr(DescrOperation, %(targetname)r)
DescrOperation.%(targetname)s = %(targetname)s
diff --git a/pypy/objspace/fake/objspace.py b/pypy/objspace/fake/objspace.py
--- a/pypy/objspace/fake/objspace.py
+++ b/pypy/objspace/fake/objspace.py
@@ -66,15 +66,16 @@
class W_MyType(W_MyObject):
name = "foobar"
flag_map_or_seq = '?'
+ hasuserdel = False
def __init__(self):
self.mro_w = [w_some_obj(), w_some_obj()]
self.dict_w = {'__str__': w_some_obj()}
+ self.hasuserdel = True
def get_module(self):
return w_some_obj()
-
def getname(self, space):
return self.name.decode('utf-8')
diff --git a/pypy/objspace/std/bytesobject.py b/pypy/objspace/std/bytesobject.py
--- a/pypy/objspace/std/bytesobject.py
+++ b/pypy/objspace/std/bytesobject.py
@@ -1,6 +1,6 @@
"""The builtin bytes implementation"""
-from rpython.rlib.jit import we_are_jitted
+from rpython.rlib import jit
from rpython.rlib.objectmodel import (
compute_hash, compute_unique_id, import_from_mixin, newlist_hint,
resizelist_hint, HASH_ALGORITHM)
@@ -529,10 +529,22 @@
@unwrap_spec(encoding='str_or_None', errors='str_or_None')
def descr_new(space, w_stringtype, w_source=None, encoding=None,
errors=None):
- if (w_source and space.is_w(space.type(w_source), space.w_bytes) and
- space.is_w(w_stringtype, space.w_bytes) and encoding is None
- and errors is None):
- return w_source
+ if (w_source and space.is_w(w_stringtype, space.w_bytes)
+ and encoding is None and errors is None):
+ # special-case 'bytes(byte_object)'
+ w_srctype = space.type(w_source)
+ if w_srctype is space.w_bytes:
+ return w_source
+ # special-case 'bytes([single_integer])' or 'bytes((single_int,))'
+ # for JITted performance only, when we clearly see the
+ # length of the list/tuple being constant and equal to 1
+ if w_srctype is space.w_list or w_srctype is space.w_tuple:
+ length = space.len_w(w_source)
+ if jit.isconstant(length) and length == 1:
+ w_item = space.getitem(w_source, space.wrap(0))
+ value = getbytevalue(space, w_item)
+ return W_BytesObject(value)
+ #
value = newbytesdata_w(space, w_source, encoding, errors)
w_obj = space.allocate_instance(W_BytesObject, w_stringtype)
W_BytesObject.__init__(w_obj, value)
diff --git a/pypy/objspace/std/test/test_bytesobject.py
b/pypy/objspace/std/test/test_bytesobject.py
--- a/pypy/objspace/std/test/test_bytesobject.py
+++ b/pypy/objspace/std/test/test_bytesobject.py
@@ -89,6 +89,13 @@
assert self.space.listview_bytes(w_bytes) == None
assert self.space.listview_int(w_bytes) == [97, 98, 99, 100]
+ def test_constructor_single_char(self, monkeypatch):
+ from rpython.rlib import jit
+ monkeypatch.setattr(jit, 'isconstant', lambda x: True)
+ space = self.space
+ w_res = space.call_function(space.w_bytes, space.wrap([42]))
+ assert space.str_w(w_res) == '*'
+
class AppTestBytesObject:
def test_constructor(self):
@@ -97,6 +104,23 @@
assert bytes(b'abc') == b'abc'
assert bytes('abc', 'ascii') == b'abc'
assert bytes(set(b'foo')) in (b'fo', b'of')
+ assert bytes([]) == b''
+ assert bytes([42]) == b'*'
+ assert bytes([0xFC]) == b'\xFC'
+ assert bytes([42, 0xCC]) == b'*\xCC'
+
+ def test_constructor_list_of_objs(self):
+ class X:
+ def __index__(self):
+ return 42
+ class Y:
+ def __int__(self):
+ return 42
+ for obj in [42, X()]:
+ assert bytes([obj]) == b'*'
+ assert bytes([obj, obj, obj]) == b'***'
+ raises(TypeError, bytes, [Y()])
+ raises(TypeError, bytes, [Y(), Y()])
def test_fromhex(self):
assert bytes.fromhex("abcd") == b'\xab\xcd'
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
@@ -1257,7 +1257,11 @@
def unicode_to_decimal_w(space, w_unistr, allow_surrogates=False):
if not isinstance(w_unistr, W_UnicodeObject):
raise oefmt(space.w_TypeError, "expected unicode, got '%T'", w_unistr)
- unistr = w_unistr._value
+ value = _rpy_unicode_to_decimal_w(space, w_unistr._value)
+ return unicodehelper.encode_utf8(space, value,
+ allow_surrogates=allow_surrogates)
+
+def _rpy_unicode_to_decimal_w(space, unistr):
result = [u'\0'] * len(unistr)
for i in xrange(len(unistr)):
uchr = ord(unistr[i])
@@ -1270,8 +1274,7 @@
except KeyError:
pass
result[i] = unichr(uchr)
- return unicodehelper.encode_utf8(space, u''.join(result),
- allow_surrogates=allow_surrogates)
+ return u''.join(result)
@jit.elidable
def g_encode_utf8(value):
diff --git a/pypy/objspace/test/test_descroperation.py
b/pypy/objspace/test/test_descroperation.py
--- a/pypy/objspace/test/test_descroperation.py
+++ b/pypy/objspace/test/test_descroperation.py
@@ -280,7 +280,8 @@
assert operate(A()) == "hello" * n
assert type(operate(A())) is str
answer = 42
- raises(TypeError, operate, A())
+ excinfo = raises(TypeError, operate, A())
+ assert "returned non-string (type 'int')" in str(excinfo.value)
def test_string_results_unicode(self):
class A(object):
diff --git a/pypy/tool/pytest/apptest.py b/pypy/tool/pytest/apptest.py
--- a/pypy/tool/pytest/apptest.py
+++ b/pypy/tool/pytest/apptest.py
@@ -21,13 +21,6 @@
pypyroot = os.path.dirname(pypydir)
-RENAMED_USEMODULES = dict(
- _winreg='winreg',
- exceptions='builtins',
- struct='_struct',
- thread='_thread',
- operator='_operator',
- )
class AppError(Exception):
def __init__(self, excinfo):
@@ -63,6 +56,11 @@
return repr(value)
+def _rename_module(name):
+ mod = __import__("pypy.module." + name, globals(), locals(), ['Module'])
+ return mod.Module.applevel_name or name
+
+
def run_with_python(python_, target_, usemodules, **definitions):
if python_ is None:
py.test.skip("Cannot find the default python3 interpreter to run with
-A")
@@ -133,8 +131,7 @@
check_usemodules = ''
if usemodules:
- usemodules = [str(RENAMED_USEMODULES.get(name, name))
- for name in usemodules]
+ usemodules = [_rename_module(name) for name in usemodules]
check_usemodules = """\
missing = set(%r).difference(sys.builtin_module_names)
if missing:
diff --git a/pypy/tool/pytest/test/test_appsupport.py
b/pypy/tool/pytest/test/test_appsupport.py
--- a/pypy/tool/pytest/test/test_appsupport.py
+++ b/pypy/tool/pytest/test/test_appsupport.py
@@ -135,3 +135,12 @@
info = raises(ZeroDivisionError, "x/0")
assert info.type is ZeroDivisionError
assert isinstance(info.value, ZeroDivisionError)
+
+def test_rename_module():
+ from pypy.tool.pytest.apptest import _rename_module
+ assert _rename_module("sys") == "sys"
+ if sys.platform == "win32":
+ assert _rename_module("_winreg") == "winreg"
+ assert _rename_module("struct") == "_struct"
+ assert _rename_module("operator") == "_operator"
+ assert _rename_module("signal") == "_signal"
diff --git a/rpython/memory/gc/incminimark.py b/rpython/memory/gc/incminimark.py
--- a/rpython/memory/gc/incminimark.py
+++ b/rpython/memory/gc/incminimark.py
@@ -155,7 +155,10 @@
# 'old_objects_pointing_to_pinned' and doesn't have to be added again.
GCFLAG_PINNED_OBJECT_PARENT_KNOWN = GCFLAG_PINNED
-_GCFLAG_FIRST_UNUSED = first_gcflag << 10 # the first unused bit
+# record that ignore_finalizer() has been called
+GCFLAG_IGNORE_FINALIZER = first_gcflag << 10
+
+_GCFLAG_FIRST_UNUSED = first_gcflag << 11 # the first unused bit
# States for the incremental GC
@@ -1161,6 +1164,11 @@
obj = self.get_forwarding_address(obj)
return self.get_type_id(obj)
+ def get_possibly_forwarded_tid(self, obj):
+ if self.is_in_nursery(obj) and self.is_forwarded(obj):
+ obj = self.get_forwarding_address(obj)
+ return self.header(obj).tid
+
def get_total_memory_used(self):
"""Return the total memory used, not counting any object in the
nursery: only objects in the ArenaCollection or raw-malloced.
@@ -1672,7 +1680,7 @@
self.rrc_minor_collection_trace()
#
# visit the "probably young" objects with finalizers. They
- # always all survive.
+ # all survive, except if IGNORE_FINALIZER is set.
if self.probably_young_objects_with_finalizers.non_empty():
self.deal_with_young_objects_with_finalizers()
#
@@ -2675,6 +2683,8 @@
while self.probably_young_objects_with_finalizers.non_empty():
obj = self.probably_young_objects_with_finalizers.popleft()
fq_nr = self.probably_young_objects_with_finalizers.popleft()
+ if self.get_possibly_forwarded_tid(obj) & GCFLAG_IGNORE_FINALIZER:
+ continue
self.singleaddr.address[0] = obj
self._trace_drag_out1(self.singleaddr)
obj = self.singleaddr.address[0]
@@ -2697,6 +2707,8 @@
fq_nr = self.old_objects_with_finalizers.popleft()
ll_assert(self._finalization_state(x) != 1,
"bad finalization state 1")
+ if self.header(x).tid & GCFLAG_IGNORE_FINALIZER:
+ continue
if self.header(x).tid & GCFLAG_VISITED:
new_with_finalizer.append(x)
new_with_finalizer.append(fq_nr)
@@ -2787,6 +2799,9 @@
self.objects_to_trace.append(obj)
self.visit_all_objects()
+ def ignore_finalizer(self, obj):
+ self.header(obj).tid |= GCFLAG_IGNORE_FINALIZER
+
# ----------
# Weakrefs
diff --git a/rpython/memory/gctransform/framework.py
b/rpython/memory/gctransform/framework.py
--- a/rpython/memory/gctransform/framework.py
+++ b/rpython/memory/gctransform/framework.py
@@ -545,6 +545,12 @@
s_gcref],
annmodel.s_None)
+ self.ignore_finalizer_ptr = None
+ if hasattr(GCClass, 'ignore_finalizer'):
+ self.ignore_finalizer_ptr = getfn(GCClass.ignore_finalizer,
+ [s_gc, SomeAddress()],
+ annmodel.s_None)
+
def create_custom_trace_funcs(self, gc, rtyper):
custom_trace_funcs = tuple(rtyper.custom_trace_funcs)
rtyper.custom_trace_funcs = custom_trace_funcs
@@ -1572,6 +1578,13 @@
hop.genop("cast_adr_to_ptr", [v_adr],
resultvar = hop.spaceop.result)
+ def gct_gc_ignore_finalizer(self, hop):
+ if self.ignore_finalizer_ptr is not None:
+ v_adr = hop.genop("cast_ptr_to_adr", [hop.spaceop.args[0]],
+ resulttype=llmemory.Address)
+ hop.genop("direct_call", [self.ignore_finalizer_ptr,
+ self.c_const_gc, v_adr])
+
class TransformerLayoutBuilder(gctypelayout.TypeLayoutBuilder):
diff --git a/rpython/rlib/rfile.py b/rpython/rlib/rfile.py
--- a/rpython/rlib/rfile.py
+++ b/rpython/rlib/rfile.py
@@ -4,7 +4,7 @@
"""
import os, stat, errno, sys
-from rpython.rlib import rposix
+from rpython.rlib import rposix, rgc
from rpython.rlib.objectmodel import enforceargs
from rpython.rlib.rarithmetic import intmask
from rpython.rlib.rstring import StringBuilder
@@ -294,6 +294,7 @@
if ll_file:
# double close is allowed
self._ll_file = lltype.nullptr(FILEP.TO)
+ rgc.may_ignore_finalizer(self)
do_close = self._close2[0]
try:
if do_close:
diff --git a/rpython/rlib/rgc.py b/rpython/rlib/rgc.py
--- a/rpython/rlib/rgc.py
+++ b/rpython/rlib/rgc.py
@@ -527,6 +527,14 @@
hop.exception_cannot_occur()
return hop.inputconst(lltype.Signed, hop.s_result.const)
+@jit.dont_look_inside
+@specialize.argtype(0)
+def may_ignore_finalizer(obj):
+ """Optimization hint: says that it is valid for any finalizer
+ for 'obj' to be ignored, depending on the GC."""
+ from rpython.rtyper.lltypesystem.lloperation import llop
+ llop.gc_ignore_finalizer(lltype.Void, obj)
+
# ____________________________________________________________
diff --git a/rpython/rtyper/lltypesystem/lloperation.py
b/rpython/rtyper/lltypesystem/lloperation.py
--- a/rpython/rtyper/lltypesystem/lloperation.py
+++ b/rpython/rtyper/lltypesystem/lloperation.py
@@ -486,6 +486,7 @@
'gc_add_memory_pressure': LLOp(),
'gc_fq_next_dead' : LLOp(),
'gc_fq_register' : LLOp(),
+ 'gc_ignore_finalizer' : LLOp(canrun=True),
'gc_rawrefcount_init': LLOp(),
'gc_rawrefcount_create_link_pypy': LLOp(),
diff --git a/rpython/rtyper/lltypesystem/opimpl.py
b/rpython/rtyper/lltypesystem/opimpl.py
--- a/rpython/rtyper/lltypesystem/opimpl.py
+++ b/rpython/rtyper/lltypesystem/opimpl.py
@@ -736,6 +736,9 @@
assert isinstance(x, bool)
return x
+def op_gc_ignore_finalizer(obj):
+ pass
+
# ____________________________________________________________
def get_op_impl(opname):
diff --git a/rpython/translator/c/src/mem.h b/rpython/translator/c/src/mem.h
--- a/rpython/translator/c/src/mem.h
+++ b/rpython/translator/c/src/mem.h
@@ -152,6 +152,7 @@
#define OP_GC_IS_RPY_INSTANCE(x, r) r = 0
#define OP_GC_DUMP_RPY_HEAP(fd, r) r = 0
#define OP_GC_SET_EXTRA_THRESHOLD(x, r) /* nothing */
+#define OP_GC_IGNORE_FINALIZER(x, r) /* nothing */
/****************************/
/* The "asmgcc" root finder */
diff --git a/rpython/translator/c/test/test_boehm.py
b/rpython/translator/c/test/test_boehm.py
--- a/rpython/translator/c/test/test_boehm.py
+++ b/rpython/translator/c/test/test_boehm.py
@@ -409,7 +409,9 @@
#
def fn():
for i in range(1000):
- fq.register_finalizer(A(i))
+ x = A(i)
+ fq.register_finalizer(x)
+ rgc.may_ignore_finalizer(x) # this is ignored with Boehm
rgc.collect()
rgc.collect()
if glob.triggered == 0:
diff --git a/rpython/translator/c/test/test_newgc.py
b/rpython/translator/c/test/test_newgc.py
--- a/rpython/translator/c/test/test_newgc.py
+++ b/rpython/translator/c/test/test_newgc.py
@@ -1705,6 +1705,38 @@
res = self.run("limited_memory_linux", -1, runner=myrunner)
assert res == 42
+ def define_ignore_finalizer(cls):
+ class X(object):
+ pass
+ class FQ(rgc.FinalizerQueue):
+ Class = X
+ def finalizer_trigger(self):
+ pass
+ queue = FQ()
+ def g():
+ x1 = X()
+ x2 = X()
+ queue.register_finalizer(x1)
+ queue.register_finalizer(x2)
+ rgc.may_ignore_finalizer(x1)
+ g._dont_inline_ = True
+ def f():
+ g()
+ rgc.collect()
+ seen = 0
+ while True:
+ obj = queue.next_dead()
+ if obj is None:
+ break
+ seen += 1
+ return seen
+ assert f() == 2 # untranslated: may_ignore_finalizer() is ignored
+ return f
+
+ def test_ignore_finalizer(self):
+ res = self.run("ignore_finalizer")
+ assert res == 1 # translated: x1 is removed from the list
+
# ____________________________________________________________________
_______________________________________________
pypy-commit mailing list
pypy-commit@python.org
https://mail.python.org/mailman/listinfo/pypy-commit
