[pypy-commit] pypy py3.5: hg merge default, with some fixes for the merge
arigo
pypy.commits at gmail.com
Thu Feb 2 10:02:21 EST 2017
Author: Armin Rigo <arigo at tunes.org>
Branch: py3.5
Changeset: r89899:066e6b9a9b2d
Date: 2017-02-02 15:59 +0100
http://bitbucket.org/pypy/pypy/changeset/066e6b9a9b2d/
Log: hg merge default, with some fixes for the merge
diff --git a/pypy/interpreter/baseobjspace.py b/pypy/interpreter/baseobjspace.py
--- a/pypy/interpreter/baseobjspace.py
+++ b/pypy/interpreter/baseobjspace.py
@@ -225,14 +225,14 @@
def buffer_w(self, space, flags):
if _does_override_buffer_w_ex(self.__class__):
return self.buffer_w_ex(space, flags)[0]
- return self._buffer(space, flags).buffer_w(space, flags)
+ return self.__buffer_w(space, flags).buffer_w(space, flags)
def buffer_w_ex(self, space, flags):
if _does_override_buffer_w(self.__class__):
return self.buffer_w(space, flags), 'B', 1
- return self._buffer(space, flags).buffer_w_ex(space, flags)
+ return self.__buffer_w(space, flags).buffer_w_ex(space, flags)
- def _buffer(self, space, flags):
+ def __buffer_w(self, space, flags):
if flags & space.BUF_WRITABLE:
w_impl = space.lookup(self, '__wbuffer__')
else:
diff --git a/pypy/interpreter/error.py b/pypy/interpreter/error.py
--- a/pypy/interpreter/error.py
+++ b/pypy/interpreter/error.py
@@ -7,7 +7,7 @@
from rpython.rlib import jit
from rpython.rlib.objectmodel import we_are_translated, specialize
-from rpython.rlib import rstackovf
+from rpython.rlib import rstack, rstackovf
from pypy.interpreter import debug
@@ -60,6 +60,7 @@
"Check if this is an exception that should better not be caught."
return (self.match(space, space.w_SystemExit) or
self.match(space, space.w_KeyboardInterrupt))
+ # note: an extra case is added in OpErrFmtNoArgs
def __str__(self):
"NOT_RPYTHON: Convenience for tracebacks."
@@ -512,6 +513,16 @@
def _compute_value(self, space):
return self._value.decode('utf-8')
+ def async(self, space):
+ # also matches a RuntimeError("maximum rec.") if the stack is
+ # still almost full, because in this case it might be a better
+ # idea to propagate the exception than eat it
+ if (self.w_type is space.w_RecursionError and
+ self._value == "maximum recursion depth exceeded" and
+ rstack.stack_almost_full()):
+ return True
+ return OperationError.async(self, space)
+
@specialize.memo()
def get_operr_class(valuefmt):
try:
diff --git a/pypy/module/__pypy__/__init__.py b/pypy/module/__pypy__/__init__.py
--- a/pypy/module/__pypy__/__init__.py
+++ b/pypy/module/__pypy__/__init__.py
@@ -88,6 +88,7 @@
'_promote' : 'interp_magic._promote',
'normalize_exc' : 'interp_magic.normalize_exc',
'StdErrPrinter' : 'interp_stderrprinter.W_StdErrPrinter',
+ 'stack_almost_full' : 'interp_magic.stack_almost_full',
}
submodules = {
diff --git a/pypy/module/__pypy__/interp_magic.py b/pypy/module/__pypy__/interp_magic.py
--- a/pypy/module/__pypy__/interp_magic.py
+++ b/pypy/module/__pypy__/interp_magic.py
@@ -9,7 +9,7 @@
from pypy.objspace.std.setobject import W_BaseSetObject
from pypy.objspace.std.typeobject import MethodCache
from pypy.objspace.std.mapdict import MapAttrCache
-from rpython.rlib import rposix, rgc
+from rpython.rlib import rposix, rgc, rstack
def internal_repr(space, w_object):
@@ -176,3 +176,7 @@
operr = OperationError(w_type, w_value, w_tb)
operr.normalize_exception(space)
return operr.get_w_value(space)
+
+def stack_almost_full(space):
+ """Return True if the stack is more than 15/16th full."""
+ return space.wrap(rstack.stack_almost_full())
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
@@ -141,12 +141,120 @@
hints={'nolength': True}))
class W_ArrayBase(W_Root):
- _attrs_ = ('space', 'len', 'allocated', '_lifeline_') # no buffer
+ _attrs_ = ('space', 'len', 'allocated', '_lifeline_', '_buffer')
def __init__(self, space):
self.space = space
self.len = 0
self.allocated = 0
+ self._buffer = lltype.nullptr(rffi.CCHARP.TO)
+
+ @rgc.must_be_light_finalizer
+ def __del__(self):
+ if self._buffer:
+ lltype.free(self._buffer, flavor='raw')
+
+ def setlen(self, size, zero=False, overallocate=True):
+ if size > 0:
+ if size > self.allocated or size < self.allocated / 2:
+ if overallocate:
+ if size < 9:
+ some = 3
+ else:
+ some = 6
+ some += size >> 3
+ else:
+ some = 0
+ self.allocated = size + some
+ byte_size = self.allocated * self.itemsize
+ if zero:
+ new_buffer = lltype.malloc(
+ rffi.CCHARP.TO, byte_size, flavor='raw',
+ add_memory_pressure=True, zero=True)
+ else:
+ new_buffer = lltype.malloc(
+ rffi.CCHARP.TO, byte_size, flavor='raw',
+ add_memory_pressure=True)
+ copy_bytes = min(size, self.len) * self.itemsize
+ rffi.c_memcpy(rffi.cast(rffi.VOIDP, new_buffer),
+ rffi.cast(rffi.VOIDP, self._buffer),
+ copy_bytes)
+ else:
+ self.len = size
+ return
+ else:
+ assert size == 0
+ self.allocated = 0
+ new_buffer = lltype.nullptr(rffi.CCHARP.TO)
+
+ if self._buffer:
+ lltype.free(self._buffer, flavor='raw')
+ self._buffer = new_buffer
+ self.len = size
+
+ def _fromiterable(self, w_seq):
+ # used by fromsequence().
+ # a more careful case if w_seq happens to be a very large
+ # iterable: don't copy the items into some intermediate list
+ w_iterator = self.space.iter(w_seq)
+ tp = self.space.type(w_iterator)
+ while True:
+ unpack_driver.jit_merge_point(selfclass=self.__class__,
+ tp=tp, self=self,
+ w_iterator=w_iterator)
+ space = self.space
+ try:
+ w_item = space.next(w_iterator)
+ except OperationError as e:
+ if not e.match(space, space.w_StopIteration):
+ raise
+ break # done
+ self.descr_append(space, w_item)
+
+ def _charbuf_start(self):
+ return self._buffer
+
+ def _buffer_as_unsigned(self):
+ return rffi.cast(lltype.Unsigned, self._buffer)
+
+ def _charbuf_stop(self):
+ keepalive_until_here(self)
+
+ def delitem(self, space, i, j):
+ if i < 0:
+ i += self.len
+ if i < 0:
+ i = 0
+ if j < 0:
+ j += self.len
+ if j < 0:
+ j = 0
+ if j > self.len:
+ j = self.len
+ if i >= j:
+ return None
+ oldbuffer = self._buffer
+ self._buffer = lltype.malloc(rffi.CCHARP.TO,
+ (self.len - (j - i)) * self.itemsize, flavor='raw',
+ add_memory_pressure=True)
+ if i:
+ rffi.c_memcpy(
+ rffi.cast(rffi.VOIDP, self._buffer),
+ rffi.cast(rffi.VOIDP, oldbuffer),
+ i * self.itemsize
+ )
+ if j < self.len:
+ rffi.c_memcpy(
+ rffi.cast(rffi.VOIDP, rffi.ptradd(self._buffer,
+ i * self.itemsize)),
+ rffi.cast(rffi.VOIDP, rffi.ptradd(oldbuffer,
+ j * self.itemsize)),
+ (self.len - j) * self.itemsize
+ )
+ self.len -= j - i
+ self.allocated = self.len
+ if oldbuffer:
+ lltype.free(oldbuffer, flavor='raw')
def buffer_w_ex(self, space, flags):
return ArrayBuffer(self, False), self.typecode, self.itemsize
@@ -170,14 +278,24 @@
Return number of occurrences of x in the array.
"""
- raise NotImplementedError
+ cnt = 0
+ for i in range(self.len):
+ # XXX jitdriver
+ w_item = self.w_getitem(space, i)
+ if space.is_true(space.eq(w_item, w_val)):
+ cnt += 1
+ return space.wrap(cnt)
def descr_index(self, space, w_x):
""" index(x)
Return index of first occurrence of x in the array.
"""
- raise NotImplementedError
+ for i in range(self.len):
+ w_item = self.w_getitem(space, i)
+ if space.is_true(space.eq(w_item, w_x)):
+ return space.wrap(i)
+ raise oefmt(space.w_ValueError, "array.index(x): x not in list")
def descr_reverse(self, space):
""" reverse()
@@ -191,7 +309,8 @@
Remove the first occurrence of x in the array.
"""
- raise NotImplementedError
+ w_idx = self.descr_index(space, w_val)
+ self.descr_pop(space, space.int_w(w_idx))
@unwrap_spec(i=int)
def descr_pop(self, space, i=-1):
@@ -507,16 +626,102 @@
return space.newseqiter(self)
def descr_add(self, space, w_other):
- raise NotImplementedError
+ if (not isinstance(w_other, W_ArrayBase)
+ or w_other.typecode != self.typecode):
+ return space.w_NotImplemented
+ a = self.constructor(space)
+ a.setlen(self.len + w_other.len, overallocate=False)
+ if self.len:
+ rffi.c_memcpy(
+ rffi.cast(rffi.VOIDP, a._buffer),
+ rffi.cast(rffi.VOIDP, self._buffer),
+ self.len * self.itemsize
+ )
+ if w_other.len:
+ rffi.c_memcpy(
+ rffi.cast(rffi.VOIDP, rffi.ptradd(a._buffer,
+ self.len * self.itemsize)),
+ rffi.cast(rffi.VOIDP, w_other._buffer),
+ w_other.len * self.itemsize
+ )
+ keepalive_until_here(self)
+ keepalive_until_here(a)
+ return a
def descr_inplace_add(self, space, w_other):
- raise NotImplementedError
+ if (not isinstance(w_other, W_ArrayBase)
+ or w_other.typecode != self.typecode):
+ return space.w_NotImplemented
+ oldlen = self.len
+ otherlen = w_other.len
+ self.setlen(oldlen + otherlen)
+ if otherlen:
+ rffi.c_memcpy(
+ rffi.cast(rffi.VOIDP, rffi.ptradd(self._buffer,
+ oldlen * self.itemsize)),
+ rffi.cast(rffi.VOIDP, w_other._buffer),
+ otherlen * self.itemsize
+ )
+ keepalive_until_here(self)
+ keepalive_until_here(w_other)
+ return self
+
+ def _mul_helper(self, space, w_repeat, is_inplace):
+ try:
+ repeat = space.getindex_w(w_repeat, space.w_OverflowError)
+ except OperationError as e:
+ if e.match(space, space.w_TypeError):
+ return space.w_NotImplemented
+ raise
+ if is_inplace:
+ a = self
+ start = 1
+ else:
+ a = self.constructor(space)
+ start = 0
+ if repeat <= start:
+ if repeat <= 0:
+ a.setlen(0, overallocate=False)
+ return a
+ oldlen = self.len
+ try:
+ newlen = ovfcheck(oldlen * repeat)
+ except OverflowError:
+ raise MemoryError
+ #
+ srcbuf = self._buffer
+ srcsize = self.len * self.itemsize
+ for i in range(srcsize):
+ if srcbuf[i] != '\x00':
+ break
+ else:
+ # the source is entirely zero: initialize the target
+ # with zeroes too
+ a.setlen(newlen, zero=True, overallocate=False)
+ return a
+ #
+ a.setlen(newlen, overallocate=False)
+ srcbuf = self._buffer # reload this, in case self is a
+ if oldlen == 1:
+ self._repeat_single_item(a, start, repeat)
+ else:
+ dstbuf = a._buffer
+ if start == 1:
+ dstbuf = rffi.ptradd(dstbuf, srcsize)
+ for r in range(start, repeat):
+ rffi.c_memcpy(rffi.cast(rffi.VOIDP, dstbuf),
+ rffi.cast(rffi.VOIDP, srcbuf),
+ srcsize)
+ dstbuf = rffi.ptradd(dstbuf, srcsize)
+ keepalive_until_here(self)
+ keepalive_until_here(a)
+ return a
def descr_mul(self, space, w_repeat):
- raise NotImplementedError
+ return self._mul_helper(space, w_repeat, False)
def descr_inplace_mul(self, space, w_repeat):
- raise NotImplementedError
+ return self._mul_helper(space, w_repeat, True)
def descr_radd(self, space, w_other):
return self.descr_add(space, w_other)
@@ -600,6 +805,7 @@
self.itemtype = itemtype
self.bytes = rffi.sizeof(itemtype)
self.arraytype = lltype.Array(itemtype, hints={'nolength': True})
+ self.arrayptrtype = lltype.Ptr(self.arraytype)
self.unwrap, _, self.convert = unwrap.partition('.')
self.signed = signed
self.canoverflow = canoverflow
@@ -694,22 +900,21 @@
return self.array._charbuf_start()
+unpack_driver = jit.JitDriver(name='unpack_array',
+ greens=['selfclass', 'tp'],
+ reds=['self', 'w_iterator'])
+
def make_array(mytype):
W_ArrayBase = globals()['W_ArrayBase']
- unpack_driver = jit.JitDriver(name='unpack_array',
- greens=['tp'],
- reds=['self', 'w_iterator'])
-
class W_Array(W_ArrayBase):
itemsize = mytype.bytes
typecode = mytype.typecode
- _attrs_ = ('space', 'len', 'allocated', '_lifeline_', 'buffer')
+ _attrs_ = W_ArrayBase._attrs_
- def __init__(self, space):
- W_ArrayBase.__init__(self, space)
- self.buffer = lltype.nullptr(mytype.arraytype)
+ def get_buffer(self):
+ return rffi.cast(mytype.arrayptrtype, self._buffer)
def item_w(self, w_item):
space = self.space
@@ -765,46 +970,6 @@
self.space.wrap(msg))
return result
- @rgc.must_be_light_finalizer
- def __del__(self):
- if self.buffer:
- lltype.free(self.buffer, flavor='raw')
-
- def setlen(self, size, zero=False, overallocate=True):
- if size > 0:
- if size > self.allocated or size < self.allocated / 2:
- if overallocate:
- if size < 9:
- some = 3
- else:
- some = 6
- some += size >> 3
- else:
- some = 0
- self.allocated = size + some
- if zero:
- new_buffer = lltype.malloc(
- mytype.arraytype, self.allocated, flavor='raw',
- add_memory_pressure=True, zero=True)
- else:
- new_buffer = lltype.malloc(
- mytype.arraytype, self.allocated, flavor='raw',
- add_memory_pressure=True)
- for i in range(min(size, self.len)):
- new_buffer[i] = self.buffer[i]
- else:
- self.len = size
- return
- else:
- assert size == 0
- self.allocated = 0
- new_buffer = lltype.nullptr(mytype.arraytype)
-
- if self.buffer:
- lltype.free(self.buffer, flavor='raw')
- self.buffer = new_buffer
- self.len = size
-
def fromsequence(self, w_seq):
space = self.space
oldlen = self.len
@@ -820,20 +985,21 @@
if lst is not None:
self.setlen(oldlen + len(lst))
try:
- buf = self.buffer
+ buf = self.get_buffer()
for num in lst:
buf[newlen] = self.item_from_int_or_float(num)
newlen += 1
except OperationError:
self.setlen(newlen)
raise
+ keepalive_until_here(self)
return
# this is the common case: w_seq is a list or a tuple
lst_w = space.listview_no_unpack(w_seq)
if lst_w is not None:
self.setlen(oldlen + len(lst_w))
- buf = self.buffer
+ buf = self.get_buffer()
try:
for w_num in lst_w:
# note: self.item_w() might invoke arbitrary code.
@@ -844,30 +1010,14 @@
buf[newlen] = self.item_w(w_num)
newlen += 1
except OperationError:
- if buf == self.buffer:
+ if buf == self.get_buffer():
self.setlen(newlen)
raise
+ keepalive_until_here(self)
return
self._fromiterable(w_seq)
- def _fromiterable(self, w_seq):
- # a more careful case if w_seq happens to be a very large
- # iterable: don't copy the items into some intermediate list
- w_iterator = self.space.iter(w_seq)
- tp = self.space.type(w_iterator)
- while True:
- unpack_driver.jit_merge_point(tp=tp, self=self,
- w_iterator=w_iterator)
- space = self.space
- try:
- w_item = space.next(w_iterator)
- except OperationError as e:
- if not e.match(space, space.w_StopIteration):
- raise
- break # done
- self.descr_append(space, w_item)
-
def extend(self, w_iterable, accept_different_array=False):
space = self.space
if isinstance(w_iterable, W_Array):
@@ -875,11 +1025,14 @@
new = w_iterable.len
self.setlen(self.len + new)
i = 0
+ buf = self.get_buffer()
+ srcbuf = w_iterable.get_buffer()
while i < new:
if oldlen + i >= self.len:
self.setlen(oldlen + i + 1)
- self.buffer[oldlen + i] = w_iterable.buffer[i]
+ buf[oldlen + i] = srcbuf[i]
i += 1
+ keepalive_until_here(w_iterable)
self.setlen(oldlen + i)
elif (not accept_different_array
and isinstance(w_iterable, W_ArrayBase)):
@@ -888,17 +1041,9 @@
else:
self.fromsequence(w_iterable)
- def _charbuf_start(self):
- return rffi.cast(rffi.CCHARP, self.buffer)
-
- def _buffer_as_unsigned(self):
- return rffi.cast(lltype.Unsigned, self.buffer)
-
- def _charbuf_stop(self):
+ def w_getitem(self, space, idx):
+ item = self.get_buffer()[idx]
keepalive_until_here(self)
-
- 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':
@@ -916,29 +1061,16 @@
x = self.item_w(w_x)
index = self.len
self.setlen(index + 1)
- self.buffer[index] = x
+ self.get_buffer()[index] = x
+ keepalive_until_here(self)
# List interface
- def descr_count(self, space, w_val):
- cnt = 0
- for i in range(self.len):
- # XXX jitdriver
- w_item = self.w_getitem(space, i)
- if space.is_true(space.eq(w_item, w_val)):
- cnt += 1
- return space.wrap(cnt)
-
- def descr_index(self, space, w_val):
- for i in range(self.len):
- w_item = self.w_getitem(space, i)
- if space.is_true(space.eq(w_item, w_val)):
- return space.wrap(i)
- raise oefmt(space.w_ValueError, "array.index(x): x not in list")
def descr_reverse(self, space):
- b = self.buffer
+ b = self.get_buffer()
for i in range(self.len / 2):
b[i], b[self.len - i - 1] = b[self.len - i - 1], b[i]
+ keepalive_until_here(self)
def descr_pop(self, space, i):
if i < 0:
@@ -946,16 +1078,14 @@
if i < 0 or i >= self.len:
raise oefmt(space.w_IndexError, "pop index out of range")
w_val = self.w_getitem(space, i)
+ b = self.get_buffer()
while i < self.len - 1:
- self.buffer[i] = self.buffer[i + 1]
+ b[i] = b[i + 1]
i += 1
+ keepalive_until_here(self)
self.setlen(self.len - 1)
return w_val
- def descr_remove(self, space, w_val):
- w_idx = self.descr_index(space, w_val)
- self.descr_pop(space, space.int_w(w_idx))
-
def descr_insert(self, space, idx, w_val):
if idx < 0:
idx += self.len
@@ -967,10 +1097,12 @@
val = self.item_w(w_val)
self.setlen(self.len + 1)
i = self.len - 1
+ b = self.get_buffer()
while i > idx:
- self.buffer[i] = self.buffer[i - 1]
+ b[i] = b[i - 1]
i -= 1
- self.buffer[i] = val
+ b[i] = val
+ keepalive_until_here(self)
def getitem_slice(self, space, w_idx):
start, stop, step, size = space.decode_index4(w_idx, self.len)
@@ -978,9 +1110,13 @@
w_a.setlen(size, overallocate=False)
assert step != 0
j = 0
+ buf = w_a.get_buffer()
+ srcbuf = self.get_buffer()
for i in range(start, stop, step):
- w_a.buffer[j] = self.buffer[i]
+ buf[j] = srcbuf[i]
j += 1
+ keepalive_until_here(self)
+ keepalive_until_here(w_a)
return w_a
def setitem(self, space, w_idx, w_item):
@@ -989,7 +1125,8 @@
raise oefmt(self.space.w_TypeError,
"can only assign array to array slice")
item = self.item_w(w_item)
- self.buffer[idx] = item
+ self.get_buffer()[idx] = item
+ keepalive_until_here(self)
def setitem_slice(self, space, w_idx, w_item):
if not isinstance(w_item, W_Array):
@@ -1006,127 +1143,21 @@
self.fromsequence(w_lst)
else:
j = 0
+ buf = self.get_buffer()
+ srcbuf = w_item.get_buffer()
for i in range(start, stop, step):
- self.buffer[i] = w_item.buffer[j]
+ buf[i] = srcbuf[j]
j += 1
+ keepalive_until_here(w_item)
+ keepalive_until_here(self)
- def delitem(self, space, i, j):
- if i < 0:
- i += self.len
- if i < 0:
- i = 0
- if j < 0:
- j += self.len
- if j < 0:
- j = 0
- if j > self.len:
- j = self.len
- if i >= j:
- return None
- oldbuffer = self.buffer
- self.buffer = lltype.malloc(
- mytype.arraytype, max(self.len - (j - i), 0), flavor='raw',
- add_memory_pressure=True)
- if i:
- rffi.c_memcpy(
- rffi.cast(rffi.VOIDP, self.buffer),
- rffi.cast(rffi.VOIDP, oldbuffer),
- i * mytype.bytes
- )
- if j < self.len:
- rffi.c_memcpy(
- rffi.cast(rffi.VOIDP, rffi.ptradd(self.buffer, i)),
- rffi.cast(rffi.VOIDP, rffi.ptradd(oldbuffer, j)),
- (self.len - j) * mytype.bytes
- )
- self.len -= j - i
- self.allocated = self.len
- if oldbuffer:
- lltype.free(oldbuffer, flavor='raw')
-
- # Add and mul methods
- def descr_add(self, space, w_other):
- if not isinstance(w_other, W_Array):
- return space.w_NotImplemented
- a = mytype.w_class(space)
- a.setlen(self.len + w_other.len, overallocate=False)
- if self.len:
- rffi.c_memcpy(
- rffi.cast(rffi.VOIDP, a.buffer),
- rffi.cast(rffi.VOIDP, self.buffer),
- self.len * mytype.bytes
- )
- if w_other.len:
- rffi.c_memcpy(
- rffi.cast(rffi.VOIDP, rffi.ptradd(a.buffer, self.len)),
- rffi.cast(rffi.VOIDP, w_other.buffer),
- w_other.len * mytype.bytes
- )
- return a
-
- def descr_inplace_add(self, space, w_other):
- if not isinstance(w_other, W_Array):
- return space.w_NotImplemented
- oldlen = self.len
- otherlen = w_other.len
- self.setlen(oldlen + otherlen)
- if otherlen:
- rffi.c_memcpy(
- rffi.cast(rffi.VOIDP, rffi.ptradd(self.buffer, oldlen)),
- rffi.cast(rffi.VOIDP, w_other.buffer),
- otherlen * mytype.bytes
- )
- return self
-
- def descr_mul(self, space, w_repeat):
- return _mul_helper(space, self, w_repeat, False)
-
- def descr_inplace_mul(self, space, w_repeat):
- return _mul_helper(space, self, w_repeat, True)
-
- def _mul_helper(space, self, w_repeat, is_inplace):
- try:
- repeat = space.getindex_w(w_repeat, space.w_OverflowError)
- except OperationError as e:
- if e.match(space, space.w_TypeError):
- return space.w_NotImplemented
- raise
- repeat = max(repeat, 0)
- try:
- newlen = ovfcheck(self.len * repeat)
- except OverflowError:
- raise MemoryError
- oldlen = self.len
- if is_inplace:
- a = self
- start = 1
- else:
- a = mytype.w_class(space)
- start = 0
- # <a performance hack>
- if oldlen == 1:
- if mytype.unwrap == 'str_w' or mytype.unwrap == 'unicode_w':
- zero = not ord(self.buffer[0])
- elif mytype.unwrap == 'int_w' or mytype.unwrap == 'bigint_w':
- zero = not widen(self.buffer[0])
- #elif mytype.unwrap == 'float_w':
- # value = ...float(self.buffer[0]) xxx handle the case of -0.0
- else:
- zero = False
- if zero:
- a.setlen(newlen, zero=True, overallocate=False)
- return a
- a.setlen(newlen, overallocate=False)
- item = self.buffer[0]
+ def _repeat_single_item(self, a, start, repeat):
+ # <a performance hack>
+ assert isinstance(a, W_Array)
+ item = self.get_buffer()[0]
+ dstbuf = a.get_buffer()
for r in range(start, repeat):
- a.buffer[r] = item
- return a
- # </a performance hack>
- a.setlen(newlen, overallocate=False)
- for r in range(start, repeat):
- for i in range(oldlen):
- a.buffer[r * oldlen + i] = self.buffer[i]
- return a
+ dstbuf[r] = item
mytype.w_class = W_Array
W_Array.constructor = W_Array
diff --git a/rpython/jit/metainterp/compile.py b/rpython/jit/metainterp/compile.py
--- a/rpython/jit/metainterp/compile.py
+++ b/rpython/jit/metainterp/compile.py
@@ -732,7 +732,8 @@
TY_FLOAT = 0x06
def handle_fail(self, deadframe, metainterp_sd, jitdriver_sd):
- if self.must_compile(deadframe, metainterp_sd, jitdriver_sd):
+ if (self.must_compile(deadframe, metainterp_sd, jitdriver_sd)
+ and not rstack.stack_almost_full()):
self.start_compiling()
try:
self._trace_and_compile_from_bridge(deadframe, metainterp_sd,
diff --git a/rpython/jit/metainterp/warmstate.py b/rpython/jit/metainterp/warmstate.py
--- a/rpython/jit/metainterp/warmstate.py
+++ b/rpython/jit/metainterp/warmstate.py
@@ -11,6 +11,7 @@
from rpython.rlib.objectmodel import specialize, we_are_translated, r_dict
from rpython.rlib.rarithmetic import intmask, r_uint
from rpython.rlib.unroll import unrolling_iterable
+from rpython.rlib import rstack
from rpython.rtyper.annlowlevel import (hlstr, cast_base_ptr_to_instance,
cast_object_to_ptr)
from rpython.rtyper.lltypesystem import lltype, llmemory, rstr, rffi
@@ -415,6 +416,8 @@
if not confirm_enter_jit(*args):
return
jitcounter.decay_all_counters()
+ if rstack.stack_almost_full():
+ return
# start tracing
from rpython.jit.metainterp.pyjitpl import MetaInterp
metainterp = MetaInterp(metainterp_sd, jitdriver_sd)
diff --git a/rpython/memory/gctransform/asmgcroot.py b/rpython/memory/gctransform/asmgcroot.py
--- a/rpython/memory/gctransform/asmgcroot.py
+++ b/rpython/memory/gctransform/asmgcroot.py
@@ -26,7 +26,6 @@
class AsmGcRootFrameworkGCTransformer(BaseFrameworkGCTransformer):
_asmgcc_save_restore_arguments = None
- _seen_gctransformer_hint_close_stack = None
def push_roots(self, hop, keep_current_args=False):
livevars = self.get_livevars_for_roots(hop, keep_current_args)
@@ -50,29 +49,28 @@
hop.genop("direct_call", [c_asm_nocollect, name])
def gct_direct_call(self, hop):
+ # just a sanity check: if we find a fnptr with the hint on the
+ # _callable, then we'd also find the hint by looking only at the
+ # graph. We'll actually change this graph only later, in
+ # start_transforming_graph().
fnptr = hop.spaceop.args[0].value
try:
close_stack = fnptr._obj._callable._gctransformer_hint_close_stack_
except AttributeError:
+ pass
+ else:
+ assert fnptr._obj.graph.func is fnptr._obj._callable
+ BaseFrameworkGCTransformer.gct_direct_call(self, hop)
+
+ def start_transforming_graph(self, graph):
+ try:
+ close_stack = graph.func._gctransformer_hint_close_stack_
+ except AttributeError:
close_stack = False
if close_stack:
- self.handle_call_with_close_stack(hop)
- else:
- BaseFrameworkGCTransformer.gct_direct_call(self, hop)
+ self._transform_hint_close_stack(graph)
- def handle_call_with_close_stack(self, hop):
- fnptr = hop.spaceop.args[0].value
- if self._seen_gctransformer_hint_close_stack is None:
- self._seen_gctransformer_hint_close_stack = {}
- if fnptr._obj.graph not in self._seen_gctransformer_hint_close_stack:
- self._transform_hint_close_stack(fnptr)
- self._seen_gctransformer_hint_close_stack[fnptr._obj.graph] = True
- #
- livevars = self.push_roots(hop)
- self.default(hop)
- self.pop_roots(hop, livevars)
-
- def _transform_hint_close_stack(self, fnptr):
+ def _transform_hint_close_stack(self, graph):
# We cannot easily pass variable amount of arguments of the call
# across the call to the pypy_asm_stackwalk helper. So we store
# them away and restore them. More precisely, we need to
@@ -83,8 +81,8 @@
sradict = self._asmgcc_save_restore_arguments
sra = [] # list of pointers to raw-malloced containers for args
seen = {}
- FUNC1 = lltype.typeOf(fnptr).TO
- for TYPE in FUNC1.ARGS:
+ ARGS = [v.concretetype for v in graph.getargs()]
+ for TYPE in ARGS:
if isinstance(TYPE, lltype.Ptr):
TYPE = llmemory.Address
num = seen.get(TYPE, 0)
@@ -98,8 +96,10 @@
sra.append(sradict[key])
#
# make a copy of the graph that will reload the values
- graph = fnptr._obj.graph
graph2 = copygraph(graph)
+ del graph2.func # otherwise, start_transforming_graph() will
+ # again transform graph2, and we get an
+ # infinite loop
#
# edit the original graph to only store the value of the arguments
block = Block(graph.startblock.inputargs)
@@ -116,17 +116,18 @@
SpaceOperation("bare_setfield", [c_p, c_item0, v_arg], v_void))
#
# call asm_stackwalk(graph2)
- FUNC2 = lltype.FuncType([], FUNC1.RESULT)
+ RESULT = graph.getreturnvar().concretetype
+ FUNC2 = lltype.FuncType([], RESULT)
fnptr2 = lltype.functionptr(FUNC2,
- fnptr._obj._name + '_reload',
+ graph.name + '_reload',
graph=graph2)
c_fnptr2 = Constant(fnptr2, lltype.Ptr(FUNC2))
HELPERFUNC = lltype.FuncType([lltype.Ptr(FUNC2),
- ASM_FRAMEDATA_HEAD_PTR], FUNC1.RESULT)
+ ASM_FRAMEDATA_HEAD_PTR], RESULT)
v_asm_stackwalk = varoftype(lltype.Ptr(HELPERFUNC), "asm_stackwalk")
block.operations.append(
SpaceOperation("cast_pointer", [c_asm_stackwalk], v_asm_stackwalk))
- v_result = varoftype(FUNC1.RESULT)
+ v_result = varoftype(RESULT)
block.operations.append(
SpaceOperation("indirect_call", [v_asm_stackwalk, c_fnptr2,
c_gcrootanchor,
diff --git a/rpython/memory/gctransform/transform.py b/rpython/memory/gctransform/transform.py
--- a/rpython/memory/gctransform/transform.py
+++ b/rpython/memory/gctransform/transform.py
@@ -201,6 +201,9 @@
self.var_last_needed_in = None
self.curr_block = None
+ def start_transforming_graph(self, graph):
+ pass # for asmgcc.py
+
def transform_graph(self, graph):
if graph in self.minimal_transform:
if self.minimalgctransformer:
@@ -210,6 +213,7 @@
if graph in self.seen_graphs:
return
self.seen_graphs.add(graph)
+ self.start_transforming_graph(graph)
self.links_to_split = {} # link -> vars to pop_alive across the link
diff --git a/rpython/rlib/rstack.py b/rpython/rlib/rstack.py
--- a/rpython/rlib/rstack.py
+++ b/rpython/rlib/rstack.py
@@ -69,3 +69,22 @@
raise _StackOverflow
stack_check_slowpath._dont_inline_ = True
stack_check_slowpath._dont_insert_stackcheck_ = True
+
+def stack_almost_full():
+ """Return True if the stack is more than 15/16th full."""
+ if not we_are_translated():
+ return False
+ # see stack_check()
+ current = llop.stack_current(lltype.Signed)
+ end = _stack_get_end()
+ length = 15 * (r_uint(_stack_get_length()) >> 4)
+ ofs = r_uint(end - current)
+ if ofs <= length:
+ return False # fine
+ else:
+ _stack_too_big_slowpath(current) # this might update the stack end
+ end = _stack_get_end()
+ ofs = r_uint(end - current)
+ return ofs > length
+stack_almost_full._dont_insert_stackcheck_ = True
+stack_almost_full._jit_look_inside_ = False
diff --git a/rpython/rlib/test/test_rsignal.py b/rpython/rlib/test/test_rsignal.py
--- a/rpython/rlib/test/test_rsignal.py
+++ b/rpython/rlib/test/test_rsignal.py
@@ -1,4 +1,4 @@
-import os, py
+import os, py, errno
from rpython.translator.c.test.test_genc import compile
from rpython.rlib import rsignal
@@ -37,3 +37,24 @@
def test_compile():
fn = compile(test_simple, [])
fn()
+
+def test_compile_wakeup_fd():
+ def fn():
+ rd, wr = os.pipe()
+ rsignal.pypysig_set_wakeup_fd(wr, False)
+ for i in range(3):
+ rsignal.pypysig_setflag(rsignal.SIGUSR1)
+ os.kill(os.getpid(), rsignal.SIGUSR1)
+ check(rsignal.SIGUSR1)
+ check(-1)
+ check(-1)
+ x = os.read(rd, 10)
+ assert x == chr(rsignal.SIGUSR1) * 3
+ #
+ rsignal.pypysig_set_wakeup_fd(rd, False) # can't write there
+ os.kill(os.getpid(), rsignal.SIGUSR1)
+
+ fn = compile(fn, [], return_stderr=True)
+ stderr = fn()
+ assert stderr.endswith('Exception ignored when trying to write to the '
+ 'signal wakeup fd: Errno %d\n' % errno.EBADF)
diff --git a/rpython/translator/c/src/signals.c b/rpython/translator/c/src/signals.c
--- a/rpython/translator/c/src/signals.c
+++ b/rpython/translator/c/src/signals.c
@@ -2,6 +2,7 @@
#include <limits.h>
#include <stdlib.h>
+#include <errno.h>
#ifdef _WIN32
#include <process.h>
#include <io.h>
@@ -82,27 +83,51 @@
}
}
+static void write_str(int fd, const char *p)
+{
+ int i = 0;
+ while (p[i] != '\x00')
+ i++;
+ (void)write(fd, p, i);
+}
+
static void signal_setflag_handler(int signum)
{
pypysig_pushback(signum);
- if (wakeup_fd != -1)
- {
+ /* Warning, this logic needs to be async-signal-safe */
+ if (wakeup_fd != -1) {
#ifndef _WIN32
ssize_t res;
#else
int res;
#endif
- if (wakeup_with_nul_byte)
- {
- res = write(wakeup_fd, "\0", 1);
- } else {
- unsigned char byte = (unsigned char)signum;
- res = write(wakeup_fd, &byte, 1);
- }
-
- /* the return value is ignored here */
- }
+ int old_errno = errno;
+ retry:
+ if (wakeup_with_nul_byte) {
+ res = write(wakeup_fd, "\0", 1);
+ } else {
+ unsigned char byte = (unsigned char)signum;
+ res = write(wakeup_fd, &byte, 1);
+ }
+ if (res < 0) {
+ unsigned int e = (unsigned int)errno;
+ char c[27], *p;
+ if (e == EINTR)
+ goto retry;
+ write_str(2, "Exception ignored when trying to write to the "
+ "signal wakeup fd: Errno ");
+ p = c + sizeof(c);
+ *--p = 0;
+ *--p = '\n';
+ do {
+ *--p = '0' + e % 10;
+ e /= 10;
+ } while (e != 0);
+ write_str(2, p);
+ }
+ errno = old_errno;
+ }
}
void pypysig_setflag(int signum)
More information about the pypy-commit
mailing list