[pypy-commit] pypy py3k: merge default
pjenvey
noreply at buildbot.pypy.org
Sun Aug 11 21:08:29 CEST 2013
Author: Philip Jenvey <pjenvey at underboss.org>
Branch: py3k
Changeset: r66076:5d26cdb39446
Date: 2013-08-11 12:07 -0700
http://bitbucket.org/pypy/pypy/changeset/5d26cdb39446/
Log: merge default
diff too long, truncating to 2000 out of 7083 lines
diff --git a/dotviewer/drawgraph.py b/dotviewer/drawgraph.py
--- a/dotviewer/drawgraph.py
+++ b/dotviewer/drawgraph.py
@@ -22,6 +22,7 @@
'yellow': (255,255,0),
}
re_nonword=re.compile(r'([^0-9a-zA-Z_.]+)')
+re_linewidth=re.compile(r'setlinewidth\((\d+(\.\d*)?|\.\d+)\)')
def combine(color1, color2, alpha):
r1, g1, b1 = color1
@@ -138,6 +139,13 @@
self.yl = float(yl)
rest = rest[3:]
self.style, self.color = rest
+ linematch = re_linewidth.match(self.style)
+ if linematch:
+ num = linematch.group(1)
+ self.linewidth = int(round(float(num)))
+ self.style = self.style[linematch.end(0):]
+ else:
+ self.linewidth = 1
self.highlight = False
self.cachedbezierpoints = None
self.cachedarrowhead = None
@@ -520,8 +528,8 @@
fgcolor = highlight_color(fgcolor)
points = [self.map(*xy) for xy in edge.bezierpoints()]
- def drawedgebody(points=points, fgcolor=fgcolor):
- pygame.draw.lines(self.screen, fgcolor, False, points)
+ def drawedgebody(points=points, fgcolor=fgcolor, width=edge.linewidth):
+ pygame.draw.lines(self.screen, fgcolor, False, points, width)
edgebodycmd.append(drawedgebody)
points = [self.map(*xy) for xy in edge.arrowhead()]
diff --git a/dotviewer/test/test_interactive.py b/dotviewer/test/test_interactive.py
--- a/dotviewer/test/test_interactive.py
+++ b/dotviewer/test/test_interactive.py
@@ -34,6 +34,23 @@
}
'''
+SOURCE2=r'''digraph f {
+ a; d; e; f; g; h; i; j; k; l;
+ a -> d [penwidth=1, style="setlinewidth(1)"];
+ d -> e [penwidth=2, style="setlinewidth(2)"];
+ e -> f [penwidth=4, style="setlinewidth(4)"];
+ f -> g [penwidth=8, style="setlinewidth(8)"];
+ g -> h [penwidth=16, style="setlinewidth(16)"];
+ h -> i [penwidth=32, style="setlinewidth(32)"];
+ i -> j [penwidth=64, style="setlinewidth(64)"];
+ j -> k [penwidth=128, style="setlinewidth(128)"];
+ k -> l [penwidth=256, style="setlinewidth(256)"];
+}'''
+
+
+
+
+
def setup_module(mod):
if not option.pygame:
py.test.skip("--pygame not enabled")
@@ -161,3 +178,10 @@
page = MyPage(str(dotfile))
page.fixedfont = True
graphclient.display_page(page)
+
+def test_linewidth():
+ udir.join("graph2.dot").write(SOURCE2)
+ from dotviewer import graphpage, graphclient
+ dotfile = udir.join('graph2.dot')
+ page = graphpage.DotFileGraphPage(str(dotfile))
+ graphclient.display_page(page)
diff --git a/lib-python/2.7/socket.py b/lib-python/2.7/socket.py
--- a/lib-python/2.7/socket.py
+++ b/lib-python/2.7/socket.py
@@ -165,6 +165,8 @@
# All _delegate_methods must also be initialized here.
send = recv = recv_into = sendto = recvfrom = recvfrom_into = _dummy
__getattr__ = _dummy
+ def _drop(self):
+ pass
# Wrapper around platform socket objects. This implements
# a platform-independent dup() functionality. The
@@ -179,12 +181,21 @@
def __init__(self, family=AF_INET, type=SOCK_STREAM, proto=0, _sock=None):
if _sock is None:
_sock = _realsocket(family, type, proto)
- elif _type(_sock) is _realsocket:
+ else:
+ # PyPy note about refcounting: implemented with _reuse()/_drop()
+ # on the class '_socket.socket'. Python 3 did it differently
+ # with a reference counter on this class 'socket._socketobject'
+ # instead, but it is a less compatible change.
+
+ # Note that a few libraries (like eventlet) poke at the
+ # private implementation of socket.py, passing custom
+ # objects to _socketobject(). These libraries need the
+ # following fix for use on PyPy: the custom objects need
+ # methods _reuse() and _drop() that maintains an explicit
+ # reference counter, starting at 0. When it drops back to
+ # zero, close() must be called.
_sock._reuse()
- # PyPy note about refcounting: implemented with _reuse()/_drop()
- # on the class '_socket.socket'. Python 3 did it differently
- # with a reference counter on this class 'socket._socketobject'
- # instead, but it is a less compatible change (breaks eventlet).
+
self._sock = _sock
def send(self, data, flags=0):
@@ -216,9 +227,8 @@
def close(self):
s = self._sock
- if type(s) is _realsocket:
- s._drop()
self._sock = _closedsocket()
+ s._drop()
close.__doc__ = _realsocket.close.__doc__
def accept(self):
@@ -280,8 +290,14 @@
"_close"]
def __init__(self, sock, mode='rb', bufsize=-1, close=False):
- if type(sock) is _realsocket:
- sock._reuse()
+ # Note that a few libraries (like eventlet) poke at the
+ # private implementation of socket.py, passing custom
+ # objects to _fileobject(). These libraries need the
+ # following fix for use on PyPy: the custom objects need
+ # methods _reuse() and _drop() that maintains an explicit
+ # reference counter, starting at 0. When it drops back to
+ # zero, close() must be called.
+ sock._reuse()
self._sock = sock
self.mode = mode # Not actually used in this version
if bufsize < 0:
@@ -317,11 +333,11 @@
self.flush()
finally:
s = self._sock
- if type(s) is _realsocket:
+ self._sock = None
+ if s is not None:
s._drop()
- if self._close:
- self._sock.close()
- self._sock = None
+ if self._close:
+ s.close()
def __del__(self):
try:
diff --git a/lib-python/2.7/ssl.py b/lib-python/2.7/ssl.py
--- a/lib-python/2.7/ssl.py
+++ b/lib-python/2.7/ssl.py
@@ -110,6 +110,12 @@
suppress_ragged_eofs=True, ciphers=None):
socket.__init__(self, _sock=sock._sock)
+ # "close" the original socket: it is not usable any more.
+ # this only calls _drop(), which should not actually call
+ # the operating system's close() because the reference
+ # counter is greater than 1 (we hold one too).
+ sock.close()
+
if ciphers is None and ssl_version != _SSLv2_IF_EXISTS:
ciphers = _DEFAULT_CIPHERS
@@ -352,11 +358,19 @@
works with the SSL connection. Just use the code
from the socket module."""
- self._makefile_refs += 1
# close=True so as to decrement the reference count when done with
# the file-like object.
return _fileobject(self, mode, bufsize, close=True)
+ def _reuse(self):
+ self._makefile_refs += 1
+
+ def _drop(self):
+ if self._makefile_refs < 1:
+ self.close()
+ else:
+ self._makefile_refs -= 1
+
def wrap_socket(sock, keyfile=None, certfile=None,
diff --git a/lib-python/2.7/test/test_socket.py b/lib-python/2.7/test/test_socket.py
--- a/lib-python/2.7/test/test_socket.py
+++ b/lib-python/2.7/test/test_socket.py
@@ -1066,6 +1066,9 @@
def recv(self, size):
return self._recv_step.next()()
+ def _reuse(self): pass
+ def _drop(self): pass
+
@staticmethod
def _raise_eintr():
raise socket.error(errno.EINTR)
@@ -1321,7 +1324,8 @@
closed = False
def flush(self): pass
def close(self): self.closed = True
- def _decref_socketios(self): pass
+ def _reuse(self): pass
+ def _drop(self): pass
# must not close unless we request it: the original use of _fileobject
# by module socket requires that the underlying socket not be closed until
diff --git a/lib-python/2.7/test/test_urllib2.py b/lib-python/2.7/test/test_urllib2.py
--- a/lib-python/2.7/test/test_urllib2.py
+++ b/lib-python/2.7/test/test_urllib2.py
@@ -270,6 +270,8 @@
self.reason = reason
def read(self):
return ''
+ def _reuse(self): pass
+ def _drop(self): pass
class MockHTTPClass:
def __init__(self):
diff --git a/lib-python/2.7/urllib2.py b/lib-python/2.7/urllib2.py
--- a/lib-python/2.7/urllib2.py
+++ b/lib-python/2.7/urllib2.py
@@ -1193,6 +1193,8 @@
# out of socket._fileobject() and into a base class.
r.recv = r.read
+ r._reuse = lambda: None
+ r._drop = lambda: None
fp = socket._fileobject(r, close=True)
resp = addinfourl(fp, r.msg, req.get_full_url())
diff --git a/lib_pypy/cffi.egg-info b/lib_pypy/cffi.egg-info
--- a/lib_pypy/cffi.egg-info
+++ b/lib_pypy/cffi.egg-info
@@ -1,6 +1,6 @@
Metadata-Version: 1.0
Name: cffi
-Version: 0.6
+Version: 0.7
Summary: Foreign Function Interface for Python calling C code.
Home-page: http://cffi.readthedocs.org
Author: Armin Rigo, Maciej Fijalkowski
diff --git a/lib_pypy/readline.egg-info b/lib_pypy/readline.egg-info
new file mode 100644
--- /dev/null
+++ b/lib_pypy/readline.egg-info
@@ -0,0 +1,10 @@
+Metadata-Version: 1.0
+Name: readline
+Version: 6.2.4.1
+Summary: Hack to make "pip install readline" happy and do nothing
+Home-page: UNKNOWN
+Author: UNKNOWN
+Author-email: UNKNOWN
+License: UNKNOWN
+Description: UNKNOWN
+Platform: UNKNOWN
diff --git a/pypy/doc/_ref.txt b/pypy/doc/_ref.txt
--- a/pypy/doc/_ref.txt
+++ b/pypy/doc/_ref.txt
@@ -98,8 +98,6 @@
.. _`rpython/rtyper/memory/gc/hybrid.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/memory/gc/hybrid.py
.. _`rpython/rtyper/memory/gc/minimarkpage.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/memory/gc/minimarkpage.py
.. _`rpython/rtyper/memory/gc/semispace.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/memory/gc/semispace.py
-.. _`rpython/rtyper/ootypesystem/`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/ootypesystem/
-.. _`rpython/rtyper/ootypesystem/ootype.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/ootypesystem/ootype.py
.. _`rpython/rtyper/rint.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/rint.py
.. _`rpython/rtyper/rlist.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/rlist.py
.. _`rpython/rtyper/rmodel.py`: https://bitbucket.org/pypy/pypy/src/default/rpython/rtyper/rmodel.py
diff --git a/pypy/doc/jit/index.rst b/pypy/doc/jit/index.rst
--- a/pypy/doc/jit/index.rst
+++ b/pypy/doc/jit/index.rst
@@ -23,7 +23,10 @@
- Hooks_ debugging facilities available to a python programmer
+- Virtualizable_ how virtualizables work and what they are (in other words how
+ to make frames more efficient).
.. _Overview: overview.html
.. _Notes: pyjitpl5.html
.. _Hooks: ../jit-hooks.html
+.. _Virtualizable: virtualizable.html
diff --git a/pypy/doc/jit/virtualizable.rst b/pypy/doc/jit/virtualizable.rst
new file mode 100644
--- /dev/null
+++ b/pypy/doc/jit/virtualizable.rst
@@ -0,0 +1,60 @@
+
+Virtualizables
+==============
+
+**Note:** this document does not have a proper introduction as to how
+to understand the basics. We should write some. If you happen to be here
+and you're missing context, feel free to pester us on IRC.
+
+Problem description
+-------------------
+
+The JIT is very good at making sure some objects are never allocated if they
+don't escape from the trace. Such objects are called ``virtuals``. However,
+if we're dealing with frames, virtuals are often not good enough. Frames
+can escape and they can also be allocated already at the moment we enter the
+JIT. In such cases we need some extra object that can still be optimized away,
+despite existing on the heap.
+
+Solution
+--------
+
+We introduce virtualizables. They're objects that exist on the heap, but their
+fields are not always in sync with whatever happens in the assembler. One
+example is that virtualizable fields can store virtual objects without
+forcing them. This is very useful for frames. Declaring an object to be
+virtualizable works like this:
+
+ class Frame(object):
+ _virtualizable_ = ['locals[*]', 'stackdepth']
+
+And we use them in ``JitDriver`` like this::
+
+ jitdriver = JitDriver(greens=[], reds=['frame'], virtualizables=['frame'])
+
+This declaration means that ``stackdepth`` is a virtualizable **field**, while
+``locals`` is a virtualizable **array** (a list stored on a virtualizable).
+There are various rules about using virtualizables, especially using
+virtualizable arrays that can be very confusing. Those will usually end
+up with a compile-time error (as opposed to strange behavior). The rules are:
+
+* Each array access must be with a known positive index that cannot raise
+ an ``IndexError``. Using ``no = jit.hint(no, promote=True)`` might be useful
+ to get a constant-number access. This is only safe if the index is actually
+ constant or changing rarely within the context of the user's code.
+
+* If you initialize a new virtualizable in the JIT, it has to be done like this
+ (for example if we're in ``Frame.__init__``)::
+
+ self = hint(self, access_directly=True, fresh_virtualizable=True)
+
+ that way you can populate the fields directly.
+
+* If you use virtualizable outside of the JIT – it's very expensive and
+ sometimes aborts tracing. Consider it carefully as to how do it only for
+ debugging purposes and not every time (e.g. ``sys._getframe`` call).
+
+* If you have something equivalent of a Python generator, where the
+ virtualizable survives for longer, you want to force it before returning.
+ It's better to do it that way than by an external call some time later.
+ It's done using ``jit.hint(frame, force_virtualizable=True)``
diff --git a/pypy/doc/whatsnew-head.rst b/pypy/doc/whatsnew-head.rst
--- a/pypy/doc/whatsnew-head.rst
+++ b/pypy/doc/whatsnew-head.rst
@@ -62,3 +62,15 @@
No longer delegate numpy string_ methods to space.StringObject, in numpy
this works by kind of by accident. Support for merging the refactor-str-types
branch
+
+.. branch: kill-typesystem
+Remove the "type system" abstraction, now that there is only ever one kind of
+type system used.
+
+.. branch: kill-gen-store-back-in
+Kills gen_store_back_in_virtualizable - should improve non-inlined calls by
+a bit
+
+.. branch: dotviewer-linewidth
+.. branch: reflex-support
+.. branch: numpypy-inplace-op
diff --git a/pypy/interpreter/pyframe.py b/pypy/interpreter/pyframe.py
--- a/pypy/interpreter/pyframe.py
+++ b/pypy/interpreter/pyframe.py
@@ -123,8 +123,8 @@
# CO_OPTIMIZED: no locals dict needed at all
# NB: this method is overridden in nestedscope.py
flags = code.co_flags
- if flags & pycode.CO_OPTIMIZED:
- return
+ if flags & pycode.CO_OPTIMIZED:
+ return
if flags & pycode.CO_NEWLOCALS:
self.w_locals = self.space.newdict(module=True)
else:
@@ -179,11 +179,10 @@
executioncontext.return_trace(self, self.space.w_None)
raise
executioncontext.return_trace(self, w_exitvalue)
- # clean up the exception, might be useful for not
- # allocating exception objects in some cases
- # if it's a generator, we have to preserve the exception state
- if not self.is_generator():
- self.last_exception = None
+ # it used to say self.last_exception = None
+ # this is now done by the code in pypyjit module
+ # since we don't want to invalidate the virtualizable
+ # for no good reason
got_exception = False
finally:
executioncontext.leave(self, w_exitvalue, got_exception)
@@ -265,7 +264,7 @@
break
w_value = self.peekvalue(delta)
self.pushvalue(w_value)
-
+
def peekvalue(self, index_from_top=0):
# NOTE: top of the stack is peekvalue(0).
# Contrast this with CPython where it's PEEK(-1).
@@ -335,7 +334,7 @@
nlocals = self.pycode.co_nlocals
values_w = self.locals_stack_w[nlocals:self.valuestackdepth]
w_valuestack = maker.slp_into_tuple_with_nulls(space, values_w)
-
+
w_blockstack = nt([block._get_state_(space) for block in self.get_blocklist()])
w_fastlocals = maker.slp_into_tuple_with_nulls(
space, self.locals_stack_w[:nlocals])
@@ -345,7 +344,7 @@
else:
w_exc_value = self.last_exception.get_w_value(space)
w_tb = w(self.last_exception.get_traceback())
-
+
tup_state = [
w(self.f_backref()),
w(self.get_builtin()),
@@ -360,7 +359,7 @@
w(f_lineno),
w_fastlocals,
space.w_None, #XXX placeholder for f_locals
-
+
#f_restricted requires no additional data!
space.w_None, ## self.w_f_trace, ignore for now
@@ -394,7 +393,7 @@
ncellvars = len(pycode.co_cellvars)
cellvars = cells[:ncellvars]
closure = cells[ncellvars:]
-
+
# do not use the instance's __init__ but the base's, because we set
# everything like cells from here
# XXX hack
@@ -481,7 +480,7 @@
### line numbers ###
- def fget_f_lineno(self, space):
+ def fget_f_lineno(self, space):
"Returns the line number of the instruction currently being executed."
if self.w_f_trace is None:
return space.wrap(self.get_last_lineno())
@@ -495,7 +494,7 @@
except OperationError, e:
raise OperationError(space.w_ValueError,
space.wrap("lineno must be an integer"))
-
+
if self.w_f_trace is None:
raise OperationError(space.w_ValueError,
space.wrap("f_lineno can only be set by a trace function."))
@@ -527,7 +526,7 @@
if ord(code[new_lasti]) in (DUP_TOP, POP_TOP):
raise OperationError(space.w_ValueError,
space.wrap("can't jump to 'except' line as there's no exception"))
-
+
# Don't jump into or out of a finally block.
f_lasti_setup_addr = -1
new_lasti_setup_addr = -1
@@ -558,12 +557,12 @@
if addr == self.last_instr:
f_lasti_setup_addr = setup_addr
break
-
+
if op >= HAVE_ARGUMENT:
addr += 3
else:
addr += 1
-
+
assert len(blockstack) == 0
if new_lasti_setup_addr != f_lasti_setup_addr:
@@ -614,10 +613,10 @@
block = self.pop_block()
block.cleanup(self)
f_iblock -= 1
-
+
self.f_lineno = new_lineno
self.last_instr = new_lasti
-
+
def get_last_lineno(self):
"Returns the line number of the instruction currently being executed."
return pytraceback.offset2lineno(self.pycode, self.last_instr)
@@ -643,8 +642,8 @@
self.f_lineno = self.get_last_lineno()
space.frame_trace_action.fire()
- def fdel_f_trace(self, space):
- self.w_f_trace = None
+ def fdel_f_trace(self, space):
+ self.w_f_trace = None
def fget_f_exc_type(self, space):
if self.last_exception is not None:
@@ -654,7 +653,7 @@
if f is not None:
return f.last_exception.w_type
return space.w_None
-
+
def fget_f_exc_value(self, space):
if self.last_exception is not None:
f = self.f_backref()
@@ -672,7 +671,7 @@
if f is not None:
return space.wrap(f.last_exception.get_traceback())
return space.w_None
-
+
def fget_f_restricted(self, space):
if space.config.objspace.honor__builtins__:
return space.wrap(self.builtin is not space.builtin)
diff --git a/pypy/interpreter/typedef.py b/pypy/interpreter/typedef.py
--- a/pypy/interpreter/typedef.py
+++ b/pypy/interpreter/typedef.py
@@ -329,10 +329,6 @@
instance=True)
base_user_setup(self, space, w_subtype)
- def setclass(self, space, w_subtype):
- # only used by descr_set___class__
- self.w__class__ = w_subtype
-
add(Proto)
subcls = type(name, (supercls,), body)
diff --git a/pypy/module/__pypy__/test/test_signal.py b/pypy/module/__pypy__/test/test_signal.py
--- a/pypy/module/__pypy__/test/test_signal.py
+++ b/pypy/module/__pypy__/test/test_signal.py
@@ -37,6 +37,7 @@
except BaseException as e:
interrupted.append(e)
finally:
+ print('subthread stops, interrupted=%r' % (interrupted,))
done.append(None)
# This is normally called by app_main.py
@@ -52,11 +53,13 @@
try:
done = []
interrupted = []
+ print('--- start ---')
_thread.start_new_thread(subthread, ())
for j in range(10):
if len(done): break
print('.')
time.sleep(0.1)
+ print('main thread loop done')
assert len(done) == 1
assert len(interrupted) == 1
assert 'KeyboardInterrupt' in interrupted[0].__class__.__name__
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
@@ -59,7 +59,7 @@
def descr_typecode(space, self):
return space.wrap(self.typecode)
-arr_eq_driver = jit.JitDriver(greens = ['comp_func'], reds = 'auto')
+arr_eq_driver = jit.JitDriver(name='array_eq_driver', greens = ['comp_func'], reds = 'auto')
EQ, NE, LT, LE, GT, GE = range(6)
def compare_arrays(space, arr1, arr2, comp_op):
diff --git a/pypy/module/binascii/interp_uu.py b/pypy/module/binascii/interp_uu.py
--- a/pypy/module/binascii/interp_uu.py
+++ b/pypy/module/binascii/interp_uu.py
@@ -61,7 +61,7 @@
return ord(bin[i])
except IndexError:
return 0
-_a2b_read._always_inline_ = True
+_b2a_read._always_inline_ = True
@unwrap_spec(bin='bufferstr')
def b2a_uu(space, bin):
diff --git a/pypy/module/cppyy/interp_cppyy.py b/pypy/module/cppyy/interp_cppyy.py
--- a/pypy/module/cppyy/interp_cppyy.py
+++ b/pypy/module/cppyy/interp_cppyy.py
@@ -592,11 +592,15 @@
def get(self, w_cppinstance, w_pycppclass):
cppinstance = self.space.interp_w(W_CPPInstance, w_cppinstance, can_be_None=True)
+ if not cppinstance:
+ raise OperationError(self.space.w_ReferenceError, self.space.wrap("attribute access requires an instance"))
offset = self._get_offset(cppinstance)
return self.converter.from_memory(self.space, w_cppinstance, w_pycppclass, offset)
def set(self, w_cppinstance, w_value):
cppinstance = self.space.interp_w(W_CPPInstance, w_cppinstance, can_be_None=True)
+ if not cppinstance:
+ raise OperationError(self.space.w_ReferenceError, self.space.wrap("attribute access requires an instance"))
offset = self._get_offset(cppinstance)
self.converter.to_memory(self.space, w_cppinstance, w_value, offset)
return self.space.w_None
diff --git a/pypy/module/cppyy/pythonify.py b/pypy/module/cppyy/pythonify.py
--- a/pypy/module/cppyy/pythonify.py
+++ b/pypy/module/cppyy/pythonify.py
@@ -426,6 +426,11 @@
# mostly for the benefit of the CINT backend, which treats std as special
gbl.std = make_cppnamespace(None, "std", None, False)
+ # install a type for enums to refer to
+ # TODO: this is correct for C++98, not for C++11 and in general there will
+ # be the same issue for all typedef'd builtin types
+ setattr(gbl, 'unsigned int', int)
+
# install for user access
cppyy.gbl = gbl
diff --git a/pypy/module/cppyy/test/test_datatypes.py b/pypy/module/cppyy/test/test_datatypes.py
--- a/pypy/module/cppyy/test/test_datatypes.py
+++ b/pypy/module/cppyy/test/test_datatypes.py
@@ -105,6 +105,13 @@
raises(IndexError, c.m_float_array.__getitem__, self.N)
raises(IndexError, c.m_double_array.__getitem__, self.N)
+ # can not access an instance member on the class
+ raises(ReferenceError, getattr, cppyy_test_data, 'm_bool')
+ raises(ReferenceError, getattr, cppyy_test_data, 'm_int')
+
+ assert not hasattr(cppyy_test_data, 'm_bool')
+ assert not hasattr(cppyy_test_data, 'm_int')
+
c.destruct()
def test03_instance_data_write_access(self):
@@ -428,12 +435,17 @@
c = cppyy_test_data()
assert isinstance(c, cppyy_test_data)
- # TODO: test that the enum is accessible as a type
+ # test that the enum is accessible as a type
+ assert cppyy_test_data.what
assert cppyy_test_data.kNothing == 6
assert cppyy_test_data.kSomething == 111
assert cppyy_test_data.kLots == 42
+ assert cppyy_test_data.what(cppyy_test_data.kNothing) == cppyy_test_data.kNothing
+ assert cppyy_test_data.what(6) == cppyy_test_data.kNothing
+ # TODO: only allow instantiations with correct values (C++11)
+
assert c.get_enum() == cppyy_test_data.kNothing
assert c.m_enum == cppyy_test_data.kNothing
@@ -455,6 +467,7 @@
assert cppyy_test_data.s_enum == cppyy_test_data.kSomething
# global enums
+ assert gbl.fruit # test type accessible
assert gbl.kApple == 78
assert gbl.kBanana == 29
assert gbl.kCitrus == 34
diff --git a/pypy/module/cpyext/number.py b/pypy/module/cpyext/number.py
--- a/pypy/module/cpyext/number.py
+++ b/pypy/module/cpyext/number.py
@@ -41,13 +41,13 @@
def PyNumber_Int(space, w_obj):
"""Returns the o converted to an integer object on success, or NULL on failure.
This is the equivalent of the Python expression int(o)."""
- return space.int(w_obj)
+ return space.call_function(space.w_int, w_obj)
@cpython_api([PyObject], PyObject)
def PyNumber_Long(space, w_obj):
"""Returns the o converted to a long integer object on success, or NULL on
failure. This is the equivalent of the Python expression long(o)."""
- return space.int(w_obj)
+ return space.call_function(space.w_int, w_obj)
@cpython_api([PyObject], PyObject)
def PyNumber_Index(space, w_obj):
diff --git a/pypy/module/cpyext/pystate.py b/pypy/module/cpyext/pystate.py
--- a/pypy/module/cpyext/pystate.py
+++ b/pypy/module/cpyext/pystate.py
@@ -3,7 +3,6 @@
from pypy.module.cpyext.pyobject import PyObject, Py_DecRef, make_ref, from_ref
from rpython.rtyper.lltypesystem import rffi, lltype
from rpython.rlib import rthread
-from pypy.module.thread import os_thread
PyInterpreterStateStruct = lltype.ForwardReference()
PyInterpreterState = lltype.Ptr(PyInterpreterStateStruct)
@@ -17,6 +16,9 @@
('dict', PyObject),
]))
+class NoThreads(Exception):
+ pass
+
@cpython_api([], PyThreadState, error=CANNOT_FAIL)
def PyEval_SaveThread(space):
"""Release the global interpreter lock (if it has been created and thread
@@ -45,10 +47,15 @@
@cpython_api([], lltype.Void)
def PyEval_InitThreads(space):
+ if not space.config.translation.thread:
+ raise NoThreads
+ from pypy.module.thread import os_thread
os_thread.setup_threads(space)
@cpython_api([], rffi.INT_real, error=CANNOT_FAIL)
def PyEval_ThreadsInitialized(space):
+ if not space.config.translation.thread:
+ return 0
return 1
# XXX: might be generally useful
@@ -236,6 +243,8 @@
"""Create a new thread state object belonging to the given interpreter
object. The global interpreter lock need not be held, but may be held if
it is necessary to serialize calls to this function."""
+ if not space.config.translation.thread:
+ raise NoThreads
rthread.gc_thread_prepare()
# PyThreadState_Get will allocate a new execution context,
# we need to protect gc and other globals with the GIL.
@@ -250,6 +259,8 @@
def PyThreadState_Clear(space, tstate):
"""Reset all information in a thread state object. The global
interpreter lock must be held."""
+ if not space.config.translation.thread:
+ raise NoThreads
Py_DecRef(space, tstate.c_dict)
tstate.c_dict = lltype.nullptr(PyObject.TO)
space.threadlocals.leave_thread(space)
diff --git a/pypy/module/cpyext/test/test_number.py b/pypy/module/cpyext/test/test_number.py
--- a/pypy/module/cpyext/test/test_number.py
+++ b/pypy/module/cpyext/test/test_number.py
@@ -19,6 +19,8 @@
def test_number_long(self, space, api):
w_l = api.PyNumber_Long(space.wrap(123))
assert api.PyLong_CheckExact(w_l)
+ w_l = api.PyNumber_Long(space.wrap("123"))
+ assert api.PyLong_CheckExact(w_l)
def test_number_int(self, space, api):
w_l = api.PyNumber_Int(space.wraplong(123L))
@@ -27,6 +29,8 @@
assert api.PyLong_CheckExact(w_l)
w_l = api.PyNumber_Int(space.wrap(42.3))
assert api.PyLong_CheckExact(w_l)
+ w_l = api.PyNumber_Int(space.wrap("42"))
+ assert api.PyLong_CheckExact(w_l)
def test_number_index(self, space, api):
w_l = api.PyNumber_Index(space.wraplong(123L))
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
@@ -737,6 +737,27 @@
descr_gt = _binop_comp_impl(_binop_impl("greater"))
descr_ge = _binop_comp_impl(_binop_impl("greater_equal"))
+ def _binop_inplace_impl(ufunc_name):
+ def impl(self, space, w_other):
+ w_out = self
+ ufunc = getattr(interp_ufuncs.get(space), ufunc_name)
+ return ufunc.call(space, [self, w_other, w_out])
+ return func_with_new_name(impl, "binop_inplace_%s_impl" % ufunc_name)
+
+ descr_iadd = _binop_inplace_impl("add")
+ descr_isub = _binop_inplace_impl("subtract")
+ descr_imul = _binop_inplace_impl("multiply")
+ descr_idiv = _binop_inplace_impl("divide")
+ descr_itruediv = _binop_inplace_impl("true_divide")
+ descr_ifloordiv = _binop_inplace_impl("floor_divide")
+ descr_imod = _binop_inplace_impl("mod")
+ descr_ipow = _binop_inplace_impl("power")
+ descr_ilshift = _binop_inplace_impl("left_shift")
+ descr_irshift = _binop_inplace_impl("right_shift")
+ descr_iand = _binop_inplace_impl("bitwise_and")
+ descr_ior = _binop_inplace_impl("bitwise_or")
+ descr_ixor = _binop_inplace_impl("bitwise_xor")
+
def _binop_right_impl(ufunc_name):
def impl(self, space, w_other, w_out=None):
w_other = convert_to_array(space, w_other)
@@ -1007,6 +1028,20 @@
__ror__ = interp2app(W_NDimArray.descr_ror),
__rxor__ = interp2app(W_NDimArray.descr_rxor),
+ __iadd__ = interp2app(W_NDimArray.descr_iadd),
+ __isub__ = interp2app(W_NDimArray.descr_isub),
+ __imul__ = interp2app(W_NDimArray.descr_imul),
+ __idiv__ = interp2app(W_NDimArray.descr_idiv),
+ __itruediv__ = interp2app(W_NDimArray.descr_itruediv),
+ __ifloordiv__ = interp2app(W_NDimArray.descr_ifloordiv),
+ __imod__ = interp2app(W_NDimArray.descr_imod),
+ __ipow__ = interp2app(W_NDimArray.descr_ipow),
+ __ilshift__ = interp2app(W_NDimArray.descr_ilshift),
+ __irshift__ = interp2app(W_NDimArray.descr_irshift),
+ __iand__ = interp2app(W_NDimArray.descr_iand),
+ __ior__ = interp2app(W_NDimArray.descr_ior),
+ __ixor__ = interp2app(W_NDimArray.descr_ixor),
+
__eq__ = interp2app(W_NDimArray.descr_eq),
__ne__ = interp2app(W_NDimArray.descr_ne),
__lt__ = interp2app(W_NDimArray.descr_lt),
diff --git a/pypy/module/micronumpy/loop.py b/pypy/module/micronumpy/loop.py
--- a/pypy/module/micronumpy/loop.py
+++ b/pypy/module/micronumpy/loop.py
@@ -155,7 +155,8 @@
obj_iter.next()
return cur_value
-reduce_cum_driver = jit.JitDriver(greens = ['shapelen', 'func', 'dtype'],
+reduce_cum_driver = jit.JitDriver(name='numpy_reduce_cum_driver',
+ greens = ['shapelen', 'func', 'dtype'],
reds = 'auto')
def compute_reduce_cumultative(obj, out, calc_dtype, func, identity):
@@ -214,8 +215,7 @@
axis_reduce__driver = jit.JitDriver(name='numpy_axis_reduce',
greens=['shapelen',
- 'func', 'dtype',
- 'identity'],
+ 'func', 'dtype'],
reds='auto')
def do_axis_reduce(shape, func, arr, dtype, axis, out, identity, cumultative,
@@ -231,8 +231,7 @@
shapelen = len(shape)
while not out_iter.done():
axis_reduce__driver.jit_merge_point(shapelen=shapelen, func=func,
- dtype=dtype, identity=identity,
- )
+ dtype=dtype)
w_val = arr_iter.getitem().convert_to(dtype)
if out_iter.first_line:
if identity is not None:
@@ -529,8 +528,9 @@
val_arr.descr_getitem(space, w_idx))
iter.next()
-byteswap_driver = jit.JitDriver(greens = ['dtype'],
- reds = 'auto')
+byteswap_driver = jit.JitDriver(name='numpy_byteswap_driver',
+ greens = ['dtype'],
+ reds = 'auto')
def byteswap(from_, to):
dtype = from_.dtype
@@ -542,8 +542,9 @@
to_iter.next()
from_iter.next()
-choose_driver = jit.JitDriver(greens = ['shapelen', 'mode', 'dtype'],
- reds = 'auto')
+choose_driver = jit.JitDriver(name='numpy_choose_driver',
+ greens = ['shapelen', 'mode', 'dtype'],
+ reds = 'auto')
def choose(space, arr, choices, shape, dtype, out, mode):
shapelen = len(shape)
@@ -572,8 +573,9 @@
out_iter.next()
arr_iter.next()
-clip_driver = jit.JitDriver(greens = ['shapelen', 'dtype'],
- reds = 'auto')
+clip_driver = jit.JitDriver(name='numpy_clip_driver',
+ greens = ['shapelen', 'dtype'],
+ reds = 'auto')
def clip(space, arr, shape, min, max, out):
arr_iter = arr.create_iter(shape)
@@ -597,8 +599,9 @@
out_iter.next()
min_iter.next()
-round_driver = jit.JitDriver(greens = ['shapelen', 'dtype'],
- reds = 'auto')
+round_driver = jit.JitDriver(name='numpy_round_driver',
+ greens = ['shapelen', 'dtype'],
+ reds = 'auto')
def round(space, arr, dtype, shape, decimals, out):
arr_iter = arr.create_iter(shape)
@@ -612,7 +615,8 @@
arr_iter.next()
out_iter.next()
-diagonal_simple_driver = jit.JitDriver(greens = ['axis1', 'axis2'],
+diagonal_simple_driver = jit.JitDriver(name='numpy_diagonal_simple_driver',
+ greens = ['axis1', 'axis2'],
reds = 'auto')
def diagonal_simple(space, arr, out, offset, axis1, axis2, size):
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
@@ -789,6 +789,49 @@
r = [1, 2] + array([1, 2])
assert (r == [2, 4]).all()
+ def test_inline_op_scalar(self):
+ from numpypy import array
+ for op in [
+ '__iadd__',
+ '__isub__',
+ '__imul__',
+ '__idiv__',
+ '__ifloordiv__',
+ '__imod__',
+ '__ipow__',
+ '__ilshift__',
+ '__irshift__',
+ '__iand__',
+ '__ior__',
+ '__ixor__']:
+ a = b = array(range(3))
+ getattr(a, op).__call__(2)
+ assert id(a) == id(b)
+
+ def test_inline_op_array(self):
+ from numpypy import array
+ for op in [
+ '__iadd__',
+ '__isub__',
+ '__imul__',
+ '__idiv__',
+ '__ifloordiv__',
+ '__imod__',
+ '__ipow__',
+ '__ilshift__',
+ '__irshift__',
+ '__iand__',
+ '__ior__',
+ '__ixor__']:
+ a = b = array(range(5))
+ c = array(range(5))
+ d = array(5 * [2])
+ getattr(a, op).__call__(d)
+ assert id(a) == id(b)
+ reg_op = op.replace('__i', '__')
+ for i in range(5):
+ assert a[i] == getattr(c[i], reg_op).__call__(d[i])
+
def test_add_list(self):
from numpypy import array, ndarray
a = array(range(5))
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
@@ -6,7 +6,7 @@
import py
from rpython.jit.metainterp import pyjitpl
from rpython.jit.metainterp.test.support import LLJitMixin
-from rpython.jit.metainterp.warmspot import reset_stats
+from rpython.jit.metainterp.warmspot import reset_stats, get_stats
from pypy.module.micronumpy import interp_boxes
from pypy.module.micronumpy.compile import FakeSpace, Parser, InterpreterState
from pypy.module.micronumpy.base import W_NDimArray
@@ -35,9 +35,10 @@
cls.code_mapping = d
cls.codes = allcodes
- def run(self, name):
+ def compile_graph(self):
+ if self.graph is not None:
+ return
space = FakeSpace()
- i = self.code_mapping[name]
codes = self.codes
def f(i):
@@ -57,14 +58,18 @@
raise TypeError(w_res)
if self.graph is None:
- interp, graph = self.meta_interp(f, [i],
+ interp, graph = self.meta_interp(f, [0],
listops=True,
backendopt=True,
graph_and_interp_only=True)
self.__class__.interp = interp
self.__class__.graph = graph
+
+ def run(self, name):
+ self.compile_graph()
reset_stats()
pyjitpl._warmrunnerdesc.memory_manager.alive_loops.clear()
+ i = self.code_mapping[name]
retval = self.interp.eval_graph(self.graph, [i])
py.test.skip("don't run for now")
return retval
@@ -134,6 +139,29 @@
'int_add': 3,
})
+ def test_reduce_compile_only_once(self):
+ self.compile_graph()
+ reset_stats()
+ pyjitpl._warmrunnerdesc.memory_manager.alive_loops.clear()
+ i = self.code_mapping['sum']
+ # run it twice
+ retval = self.interp.eval_graph(self.graph, [i])
+ retval = self.interp.eval_graph(self.graph, [i])
+ # check that we got only one loop
+ assert len(get_stats().loops) == 1
+
+ def test_reduce_axis_compile_only_once(self):
+ self.compile_graph()
+ reset_stats()
+ pyjitpl._warmrunnerdesc.memory_manager.alive_loops.clear()
+ i = self.code_mapping['axissum']
+ # run it twice
+ retval = self.interp.eval_graph(self.graph, [i])
+ retval = self.interp.eval_graph(self.graph, [i])
+ # check that we got only one loop
+ assert len(get_stats().loops) == 1
+
+
def define_prod():
return """
a = |30|
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
@@ -12,18 +12,18 @@
from pypy.interpreter.error import OperationError, operationerrfmt
from pypy.interpreter.pycode import PyCode, CO_GENERATOR
from pypy.interpreter.pyframe import PyFrame
-from pypy.interpreter.pyopcode import ExitFrame
+from pypy.interpreter.pyopcode import ExitFrame, Yield
from opcode import opmap
-PyFrame._virtualizable2_ = ['last_instr', 'pycode',
- 'valuestackdepth', 'locals_stack_w[*]',
- 'cells[*]',
- 'last_exception',
- 'lastblock',
- 'is_being_profiled',
- 'w_globals',
- 'w_f_trace',
- ]
+PyFrame._virtualizable_ = ['last_instr', 'pycode',
+ 'valuestackdepth', 'locals_stack_w[*]',
+ 'cells[*]',
+ 'last_exception',
+ 'lastblock',
+ 'is_being_profiled',
+ 'w_globals',
+ 'w_f_trace',
+ ]
JUMP_ABSOLUTE = opmap['JUMP_ABSOLUTE']
@@ -77,7 +77,13 @@
self.valuestackdepth = hint(self.valuestackdepth, promote=True)
next_instr = self.handle_bytecode(co_code, next_instr, ec)
is_being_profiled = self.is_being_profiled
+ except Yield:
+ self.last_exception = None
+ w_result = self.popvalue()
+ jit.hint(self, force_virtualizable=True)
+ return w_result
except ExitFrame:
+ self.last_exception = None
return self.popvalue()
def jump_absolute(self, jumpto, ec):
diff --git a/pypy/module/pypyjit/test_pypy_c/test_containers.py b/pypy/module/pypyjit/test_pypy_c/test_containers.py
--- a/pypy/module/pypyjit/test_pypy_c/test_containers.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_containers.py
@@ -87,7 +87,7 @@
i8 = int_lt(i5, i7)
guard_true(i8, descr=...)
guard_not_invalidated(descr=...)
- p10 = call(ConstClass(ll_int_str), i5, descr=<Callr . i EF=3>)
+ p10 = call(ConstClass(ll_str__IntegerR_SignedConst_Signed), i5, descr=<Callr . i EF=3>)
guard_no_exception(descr=...)
i12 = call(ConstClass(ll_strhash), p10, descr=<Calli . r EF=0>)
p13 = new(descr=...)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_generators.py b/pypy/module/pypyjit/test_pypy_c/test_generators.py
--- a/pypy/module/pypyjit/test_pypy_c/test_generators.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_generators.py
@@ -19,6 +19,7 @@
log = self.run(main, [500])
loop, = log.loops_by_filename(self.filepath)
assert loop.match_by_id("generator", """
+ cond_call(..., descr=...)
i16 = force_token()
p45 = new_with_vtable(ConstClass(W_IntObject))
setfield_gc(p45, i29, descr=<FieldS .*>)
diff --git a/pypy/module/test_lib_pypy/test_curses.py b/pypy/module/test_lib_pypy/test_curses.py
--- a/pypy/module/test_lib_pypy/test_curses.py
+++ b/pypy/module/test_lib_pypy/test_curses.py
@@ -1,6 +1,15 @@
+import pytest
+
+# Check that lib_pypy.cffi finds the correct version of _cffi_backend.
+# Otherwise, the test is skipped. It should never be skipped when run
+# with "pypy py.test -A".
+try:
+ from lib_pypy import cffi; cffi.FFI()
+except (ImportError, AssertionError), e:
+ pytest.skip("no cffi module or wrong version (%s)" % (e,))
+
from lib_pypy import _curses
-import pytest
lib = _curses.lib
diff --git a/pypy/tool/pypyjit_child.py b/pypy/tool/pypyjit_child.py
--- a/pypy/tool/pypyjit_child.py
+++ b/pypy/tool/pypyjit_child.py
@@ -14,9 +14,9 @@
return lltype.nullptr(T)
interp.heap.malloc_nonmovable = returns_null # XXX
- from rpython.jit.backend.llgraph.runner import LLtypeCPU
+ from rpython.jit.backend.llgraph.runner import LLGraphCPU
#LLtypeCPU.supports_floats = False # for now
- apply_jit(interp, graph, LLtypeCPU)
+ apply_jit(interp, graph, LLGraphCPU)
def apply_jit(interp, graph, CPUClass):
diff --git a/pypy/tool/release/package.py b/pypy/tool/release/package.py
--- a/pypy/tool/release/package.py
+++ b/pypy/tool/release/package.py
@@ -3,7 +3,7 @@
It uses 'pypy/goal/pypy-c' and parts of the rest of the working
copy. Usage:
- package.py root-pypy-dir [--nostrip] [--without-tk] [name-of-archive] [name-of-pypy-c] [destination-for-tarball] [pypy-c-path]
+ package.py [--nostrip] [--without-tk] root-pypy-dir [name-of-archive] [name-of-pypy-c] [destination-for-tarball] [pypy-c-path]
Usually you would do: package.py ../../.. pypy-VER-PLATFORM
The output is found in the directory /tmp/usession-YOURNAME/build/.
diff --git a/rpython/annotator/description.py b/rpython/annotator/description.py
--- a/rpython/annotator/description.py
+++ b/rpython/annotator/description.py
@@ -391,6 +391,7 @@
instance_level = False
all_enforced_attrs = None # or a set
settled = False
+ _detect_invalid_attrs = None
def __init__(self, bookkeeper, pyobj=None,
name=None, basedesc=None, classdict=None,
@@ -714,6 +715,10 @@
# by changing the result's annotation (but not, of course, doing an
# actual copy in the rtyper). Tested in rpython.rtyper.test.test_rlist,
# test_immutable_list_out_of_instance.
+ if self._detect_invalid_attrs and attr in self._detect_invalid_attrs:
+ raise Exception("field %r was migrated to %r from a subclass in "
+ "which it was declared as _immutable_fields_" %
+ (attr, self.pyobj))
search1 = '%s[*]' % (attr,)
search2 = '%s?[*]' % (attr,)
cdesc = self
@@ -724,6 +729,14 @@
s_result.listdef.never_resize()
s_copy = s_result.listdef.offspring()
s_copy.listdef.mark_as_immutable()
+ #
+ cdesc = cdesc.basedesc
+ while cdesc is not None:
+ if cdesc._detect_invalid_attrs is None:
+ cdesc._detect_invalid_attrs = set()
+ cdesc._detect_invalid_attrs.add(attr)
+ cdesc = cdesc.basedesc
+ #
return s_copy
cdesc = cdesc.basedesc
return s_result # common case
diff --git a/rpython/annotator/specialize.py b/rpython/annotator/specialize.py
--- a/rpython/annotator/specialize.py
+++ b/rpython/annotator/specialize.py
@@ -379,4 +379,4 @@
def specialize_call_location(funcdesc, args_s, op):
assert op is not None
- return maybe_star_args(funcdesc, op, args_s)
+ return maybe_star_args(funcdesc, (op,), args_s)
diff --git a/rpython/annotator/test/test_annrpython.py b/rpython/annotator/test/test_annrpython.py
--- a/rpython/annotator/test/test_annrpython.py
+++ b/rpython/annotator/test/test_annrpython.py
@@ -3088,7 +3088,7 @@
from rpython.rlib.jit import hint
class A:
- _virtualizable2_ = []
+ _virtualizable_ = []
class B(A):
def meth(self):
return self
@@ -3128,7 +3128,7 @@
from rpython.rlib.jit import hint
class A:
- _virtualizable2_ = []
+ _virtualizable_ = []
class I:
pass
@@ -3717,6 +3717,24 @@
a = self.RPythonAnnotator()
a.build_types(f, [int])
+ def test_immutable_field_subclass(self):
+ class Root:
+ pass
+ class A(Root):
+ _immutable_fields_ = '_my_lst[*]'
+ def __init__(self, lst):
+ self._my_lst = lst
+ def foo(x):
+ return len(x._my_lst)
+
+ def f(n):
+ foo(A([2, n]))
+ foo(Root())
+
+ a = self.RPythonAnnotator()
+ e = py.test.raises(Exception, a.build_types, f, [int])
+ assert "field '_my_lst' was migrated" in str(e.value)
+
def test_call_classes_with_noarg_init(self):
class A:
foo = 21
diff --git a/rpython/jit/backend/arm/opassembler.py b/rpython/jit/backend/arm/opassembler.py
--- a/rpython/jit/backend/arm/opassembler.py
+++ b/rpython/jit/backend/arm/opassembler.py
@@ -959,16 +959,6 @@
pmc.B_offs(self.mc.currpos(), c.EQ)
return pos
- def _call_assembler_reset_vtoken(self, jd, vloc):
- from rpython.jit.backend.llsupport.descr import FieldDescr
- fielddescr = jd.vable_token_descr
- assert isinstance(fielddescr, FieldDescr)
- ofs = fielddescr.offset
- tmploc = self._regalloc.get_scratch_reg(INT)
- self.mov_loc_loc(vloc, r.ip)
- self.mc.MOV_ri(tmploc.value, 0)
- self.mc.STR_ri(tmploc.value, r.ip.value, ofs)
-
def _call_assembler_load_result(self, op, result_loc):
if op.result is not None:
# load the return value from (tmploc, 0)
diff --git a/rpython/jit/backend/llgraph/runner.py b/rpython/jit/backend/llgraph/runner.py
--- a/rpython/jit/backend/llgraph/runner.py
+++ b/rpython/jit/backend/llgraph/runner.py
@@ -101,6 +101,9 @@
self.fieldname = fieldname
self.FIELD = getattr(S, fieldname)
+ def get_vinfo(self):
+ return self.vinfo
+
def __repr__(self):
return 'FieldDescr(%r, %r)' % (self.S, self.fieldname)
@@ -170,7 +173,7 @@
translate_support_code = False
is_llgraph = True
- def __init__(self, rtyper, stats=None, *ignored_args, **ignored_kwds):
+ def __init__(self, rtyper, stats=None, *ignored_args, **kwds):
model.AbstractCPU.__init__(self)
self.rtyper = rtyper
self.llinterp = LLInterpreter(rtyper)
@@ -178,6 +181,7 @@
class MiniStats:
pass
self.stats = stats or MiniStats()
+ self.vinfo_for_tests = kwds.get('vinfo_for_tests', None)
def compile_loop(self, inputargs, operations, looptoken, log=True, name=''):
clt = model.CompiledLoopToken(self, looptoken.number)
@@ -316,6 +320,8 @@
except KeyError:
descr = FieldDescr(S, fieldname)
self.descrs[key] = descr
+ if self.vinfo_for_tests is not None:
+ descr.vinfo = self.vinfo_for_tests
return descr
def arraydescrof(self, A):
@@ -496,6 +502,8 @@
def bh_raw_store_i(self, struct, offset, newvalue, descr):
ll_p = rffi.cast(rffi.CCHARP, struct)
ll_p = rffi.cast(lltype.Ptr(descr.A), rffi.ptradd(ll_p, offset))
+ if descr.A.OF == lltype.SingleFloat:
+ newvalue = longlong.int2singlefloat(newvalue)
ll_p[0] = rffi.cast(descr.A.OF, newvalue)
def bh_raw_store_f(self, struct, offset, newvalue, descr):
@@ -600,6 +608,7 @@
forced_deadframe = None
overflow_flag = False
last_exception = None
+ force_guard_op = None
def __init__(self, cpu, argboxes, args):
self.env = {}
@@ -766,6 +775,8 @@
if self.forced_deadframe is not None:
saved_data = self.forced_deadframe._saved_data
self.fail_guard(descr, saved_data)
+ self.force_guard_op = self.current_op
+ execute_guard_not_forced_2 = execute_guard_not_forced
def execute_guard_not_invalidated(self, descr):
if self.lltrace.invalid:
@@ -887,7 +898,6 @@
# res = CALL assembler_call_helper(pframe)
# jmp @done
# @fastpath:
- # RESET_VABLE
# res = GETFIELD(pframe, 'result')
# @done:
#
@@ -907,25 +917,17 @@
vable = lltype.nullptr(llmemory.GCREF.TO)
#
# Emulate the fast path
- def reset_vable(jd, vable):
- if jd.index_of_virtualizable != -1:
- fielddescr = jd.vable_token_descr
- NULL = lltype.nullptr(llmemory.GCREF.TO)
- self.cpu.bh_setfield_gc(vable, NULL, fielddescr)
+ #
faildescr = self.cpu.get_latest_descr(pframe)
if faildescr == self.cpu.done_with_this_frame_descr_int:
- reset_vable(jd, vable)
return self.cpu.get_int_value(pframe, 0)
elif faildescr == self.cpu.done_with_this_frame_descr_ref:
- reset_vable(jd, vable)
return self.cpu.get_ref_value(pframe, 0)
elif faildescr == self.cpu.done_with_this_frame_descr_float:
- reset_vable(jd, vable)
return self.cpu.get_float_value(pframe, 0)
elif faildescr == self.cpu.done_with_this_frame_descr_void:
- reset_vable(jd, vable)
return None
- #
+
assembler_helper_ptr = jd.assembler_helper_adr.ptr # fish
try:
result = assembler_helper_ptr(pframe, vable)
diff --git a/rpython/jit/backend/llsupport/assembler.py b/rpython/jit/backend/llsupport/assembler.py
--- a/rpython/jit/backend/llsupport/assembler.py
+++ b/rpython/jit/backend/llsupport/assembler.py
@@ -2,7 +2,7 @@
from rpython.jit.backend.llsupport.memcpy import memcpy_fn
from rpython.jit.backend.llsupport.symbolic import WORD
from rpython.jit.metainterp.history import (INT, REF, FLOAT, JitCellToken,
- ConstInt, BoxInt)
+ ConstInt, BoxInt, AbstractFailDescr)
from rpython.jit.metainterp.resoperation import ResOperation, rop
from rpython.rlib import rgc
from rpython.rlib.debug import (debug_start, debug_stop, have_debug_prints,
@@ -24,6 +24,7 @@
class GuardToken(object):
def __init__(self, cpu, gcmap, faildescr, failargs, fail_locs, exc,
frame_depth, is_guard_not_invalidated, is_guard_not_forced):
+ assert isinstance(faildescr, AbstractFailDescr)
self.cpu = cpu
self.faildescr = faildescr
self.failargs = failargs
@@ -232,11 +233,8 @@
jmp_location = self._call_assembler_patch_je(result_loc, je_location)
- # Path B: fast path. Must load the return value, and reset the token
+ # Path B: fast path. Must load the return value
- # Reset the vable token --- XXX really too much special logic here:-(
- if jd.index_of_virtualizable >= 0:
- self._call_assembler_reset_vtoken(jd, vloc)
#
self._call_assembler_load_result(op, result_loc)
#
diff --git a/rpython/jit/backend/llsupport/descr.py b/rpython/jit/backend/llsupport/descr.py
--- a/rpython/jit/backend/llsupport/descr.py
+++ b/rpython/jit/backend/llsupport/descr.py
@@ -76,7 +76,13 @@
FLAG_STRUCT = 'X'
FLAG_VOID = 'V'
-class FieldDescr(AbstractDescr):
+class ArrayOrFieldDescr(AbstractDescr):
+ vinfo = None
+
+ def get_vinfo(self):
+ return self.vinfo
+
+class FieldDescr(ArrayOrFieldDescr):
name = ''
offset = 0 # help translation
field_size = 0
@@ -150,12 +156,13 @@
# ____________________________________________________________
# ArrayDescrs
-class ArrayDescr(AbstractDescr):
+class ArrayDescr(ArrayOrFieldDescr):
tid = 0
basesize = 0 # workaround for the annotator
itemsize = 0
lendescr = None
flag = '\x00'
+ vinfo = None
def __init__(self, basesize, itemsize, lendescr, flag):
self.basesize = basesize
diff --git a/rpython/jit/backend/llsupport/llmodel.py b/rpython/jit/backend/llsupport/llmodel.py
--- a/rpython/jit/backend/llsupport/llmodel.py
+++ b/rpython/jit/backend/llsupport/llmodel.py
@@ -721,12 +721,8 @@
def bh_raw_load_i(self, addr, offset, descr):
ofs, size, sign = self.unpack_arraydescr_size(descr)
- items = addr + offset
- for TYPE, _, itemsize in unroll_basic_sizes:
- if size == itemsize:
- items = rffi.cast(rffi.CArrayPtr(TYPE), items)
- return rffi.cast(lltype.Signed, items[0])
- assert False # unreachable code
+ assert ofs == 0 # otherwise, 'descr' is not a raw length-less array
+ return self.read_int_at_mem(addr, offset, size, sign)
def bh_raw_load_f(self, addr, offset, descr):
items = rffi.cast(rffi.CArrayPtr(longlong.FLOATSTORAGE), addr + offset)
diff --git a/rpython/jit/backend/llsupport/test/ztranslation_test.py b/rpython/jit/backend/llsupport/test/ztranslation_test.py
--- a/rpython/jit/backend/llsupport/test/ztranslation_test.py
+++ b/rpython/jit/backend/llsupport/test/ztranslation_test.py
@@ -23,7 +23,7 @@
# - floats neg and abs
class Frame(object):
- _virtualizable2_ = ['i']
+ _virtualizable_ = ['i']
def __init__(self, i):
self.i = i
@@ -98,7 +98,7 @@
self.val = val
class Frame(object):
- _virtualizable2_ = ['thing']
+ _virtualizable_ = ['thing']
driver = JitDriver(greens = ['codeno'], reds = ['i', 'frame'],
virtualizables = ['frame'],
diff --git a/rpython/jit/backend/model.py b/rpython/jit/backend/model.py
--- a/rpython/jit/backend/model.py
+++ b/rpython/jit/backend/model.py
@@ -6,7 +6,7 @@
total_compiled_loops = 0
total_compiled_bridges = 0
total_freed_loops = 0
- total_freed_bridges = 0
+ total_freed_bridges = 0
# for heaptracker
# _all_size_descrs_with_vtable = None
@@ -182,7 +182,7 @@
def arraydescrof(self, A):
raise NotImplementedError
- def calldescrof(self, FUNC, ARGS, RESULT):
+ def calldescrof(self, FUNC, ARGS, RESULT, extrainfo):
# FUNC is the original function type, but ARGS is a list of types
# with Voids removed
raise NotImplementedError
@@ -294,7 +294,6 @@
def bh_copyunicodecontent(self, src, dst, srcstart, dststart, length):
raise NotImplementedError
-
class CompiledLoopToken(object):
asmmemmgr_blocks = None
asmmemmgr_gcroots = 0
diff --git a/rpython/jit/backend/test/runner_test.py b/rpython/jit/backend/test/runner_test.py
--- a/rpython/jit/backend/test/runner_test.py
+++ b/rpython/jit/backend/test/runner_test.py
@@ -3954,8 +3954,12 @@
p = rawstorage.alloc_raw_storage(31)
for i in range(31):
p[i] = '\xDD'
- value = rffi.cast(T, 0x4243444546474849)
+ value = rffi.cast(T, -0x4243444546474849)
rawstorage.raw_storage_setitem(p, 16, value)
+ got = self.cpu.bh_raw_load_i(rffi.cast(lltype.Signed, p), 16,
+ arraydescr)
+ assert got == rffi.cast(lltype.Signed, value)
+ #
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
@@ -3981,6 +3985,11 @@
p[i] = '\xDD'
value = rffi.cast(T, 1.12e20)
rawstorage.raw_storage_setitem(p, 16, value)
+ got = self.cpu.bh_raw_load_f(rffi.cast(lltype.Signed, p), 16,
+ arraydescr)
+ got = longlong.getrealfloat(got)
+ assert got == rffi.cast(lltype.Float, value)
+ #
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
@@ -3991,22 +4000,58 @@
assert result == rffi.cast(lltype.Float, value)
rawstorage.free_raw_storage(p)
+ def test_raw_load_singlefloat(self):
+ if not self.cpu.supports_singlefloats:
+ py.test.skip("requires singlefloats")
+ from rpython.rlib import rawstorage
+ for T in [rffi.FLOAT]:
+ ops = """
+ [i0, i1]
+ i2 = raw_load(i0, i1, descr=arraydescr)
+ finish(i2)
+ """
+ arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
+ p = rawstorage.alloc_raw_storage(31)
+ for i in range(31):
+ p[i] = '\xDD'
+ value = rffi.cast(T, 1.12e20)
+ rawstorage.raw_storage_setitem(p, 16, value)
+ got = self.cpu.bh_raw_load_i(rffi.cast(lltype.Signed, p), 16,
+ arraydescr)
+ assert got == longlong.singlefloat2int(value)
+ #
+ loop = parse(ops, self.cpu, namespace=locals())
+ looptoken = JitCellToken()
+ self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
+ deadframe = self.cpu.execute_token(looptoken,
+ rffi.cast(lltype.Signed, p), 16)
+ result = self.cpu.get_int_value(deadframe, 0)
+ assert result == longlong.singlefloat2int(value)
+ rawstorage.free_raw_storage(p)
+
def test_raw_store_int(self):
from rpython.rlib import rawstorage
for T in [rffi.UCHAR, rffi.SIGNEDCHAR,
rffi.USHORT, rffi.SHORT,
rffi.UINT, rffi.INT,
rffi.ULONG, rffi.LONG]:
+ arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
+ p = rawstorage.alloc_raw_storage(31)
+ value = (-0x4243444546474849) & sys.maxint
+ self.cpu.bh_raw_store_i(rffi.cast(lltype.Signed, p), 16, value,
+ arraydescr)
+ result = rawstorage.raw_storage_getitem(T, p, 16)
+ assert result == rffi.cast(T, value)
+ rawstorage.free_raw_storage(p)
+ #
ops = """
[i0, i1, i2]
raw_store(i0, i1, i2, descr=arraydescr)
finish()
"""
- arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
p = rawstorage.alloc_raw_storage(31)
for i in range(31):
p[i] = '\xDD'
- value = 0x4243444546474849 & sys.maxint
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
@@ -4021,16 +4066,24 @@
py.test.skip("requires floats")
from rpython.rlib import rawstorage
for T in [rffi.DOUBLE]:
+ arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
+ p = rawstorage.alloc_raw_storage(31)
+ value = 1.23e20
+ self.cpu.bh_raw_store_f(rffi.cast(lltype.Signed, p), 16,
+ longlong.getfloatstorage(value),
+ arraydescr)
+ result = rawstorage.raw_storage_getitem(T, p, 16)
+ assert result == rffi.cast(T, value)
+ rawstorage.free_raw_storage(p)
+ #
ops = """
[i0, i1, f2]
raw_store(i0, i1, f2, descr=arraydescr)
finish()
"""
- arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
p = rawstorage.alloc_raw_storage(31)
for i in range(31):
p[i] = '\xDD'
- value = 1.23e20
loop = parse(ops, self.cpu, namespace=locals())
looptoken = JitCellToken()
self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
@@ -4041,6 +4094,41 @@
assert result == rffi.cast(T, value)
rawstorage.free_raw_storage(p)
+ def test_raw_store_singlefloat(self):
+ if not self.cpu.supports_singlefloats:
+ py.test.skip("requires singlefloats")
+ from rpython.rlib import rawstorage
+ for T in [rffi.FLOAT]:
+ arraydescr = self.cpu.arraydescrof(rffi.CArray(T))
+ p = rawstorage.alloc_raw_storage(31)
+ value = rffi.cast(T, 1.23e20)
+ self.cpu.bh_raw_store_i(rffi.cast(lltype.Signed, p), 16,
+ longlong.singlefloat2int(value),
+ arraydescr)
+ result = rawstorage.raw_storage_getitem(T, p, 16)
+ assert (rffi.cast(lltype.Float, result) ==
+ rffi.cast(lltype.Float, value))
+ rawstorage.free_raw_storage(p)
+ #
+ ops = """
+ [i0, i1, i2]
+ raw_store(i0, i1, i2, descr=arraydescr)
+ finish()
+ """
+ p = rawstorage.alloc_raw_storage(31)
+ for i in range(31):
+ p[i] = '\xDD'
+ loop = parse(ops, self.cpu, namespace=locals())
+ looptoken = JitCellToken()
+ self.cpu.compile_loop(loop.inputargs, loop.operations, looptoken)
+ self.cpu.execute_token(looptoken,
+ rffi.cast(lltype.Signed, p), 16,
+ longlong.singlefloat2int(value))
+ result = rawstorage.raw_storage_getitem(T, p, 16)
+ assert (rffi.cast(lltype.Float, result) ==
+ rffi.cast(lltype.Float, value))
+ rawstorage.free_raw_storage(p)
+
def test_forcing_op_with_fail_arg_in_reg(self):
values = []
def maybe_force(token, flag):
diff --git a/rpython/jit/backend/test/support.py b/rpython/jit/backend/test/support.py
--- a/rpython/jit/backend/test/support.py
+++ b/rpython/jit/backend/test/support.py
@@ -59,7 +59,7 @@
t.buildannotator().build_types(function, [int] * len(args),
main_entry_point=True)
- t.buildrtyper(type_system=self.type_system).specialize()
+ t.buildrtyper().specialize()
warmrunnerdesc = WarmRunnerDesc(t, translate_support_code=True,
CPUClass=self.CPUClass,
**kwds)
diff --git a/rpython/jit/backend/x86/assembler.py b/rpython/jit/backend/x86/assembler.py
--- a/rpython/jit/backend/x86/assembler.py
+++ b/rpython/jit/backend/x86/assembler.py
@@ -79,6 +79,7 @@
allblocks)
self.target_tokens_currently_compiling = {}
self.frame_depth_to_patch = []
+ self._finish_gcmap = lltype.nullptr(jitframe.GCMAP)
def teardown(self):
self.pending_guard_tokens = None
@@ -1846,7 +1847,11 @@
self.mov(fail_descr_loc, RawEbpLoc(ofs))
arglist = op.getarglist()
if arglist and arglist[0].type == REF:
- gcmap = self.gcmap_for_finish
+ if self._finish_gcmap:
+ self._finish_gcmap[0] |= r_uint(1) # rax
+ gcmap = self._finish_gcmap
+ else:
+ gcmap = self.gcmap_for_finish
self.push_gcmap(self.mc, gcmap, store=True)
else:
# note that the 0 here is redundant, but I would rather
@@ -1991,15 +1996,6 @@
#
return jmp_location
- def _call_assembler_reset_vtoken(self, jd, vloc):
- from rpython.jit.backend.llsupport.descr import FieldDescr
- fielddescr = jd.vable_token_descr
- assert isinstance(fielddescr, FieldDescr)
- vtoken_ofs = fielddescr.offset
- self.mc.MOV(edx, vloc) # we know vloc is on the current frame
- self.mc.MOV_mi((edx.value, vtoken_ofs), 0)
- # in the line above, TOKEN_NONE = 0
-
def _call_assembler_load_result(self, op, result_loc):
if op.result is not None:
# load the return value from the dead frame's value index 0
@@ -2326,6 +2322,15 @@
assert 0 < offset <= 127
self.mc.overwrite(jmp_location - 1, chr(offset))
+ def store_force_descr(self, op, fail_locs, frame_depth):
+ guard_token = self.implement_guard_recovery(op.opnum,
+ op.getdescr(),
+ op.getfailargs(),
+ fail_locs, frame_depth)
+ self._finish_gcmap = guard_token.gcmap
+ self._store_force_index(op)
+ self.store_info_on_descr(0, guard_token)
+
def force_token(self, reg):
# XXX kill me
assert isinstance(reg, RegLoc)
diff --git a/rpython/jit/backend/x86/regalloc.py b/rpython/jit/backend/x86/regalloc.py
--- a/rpython/jit/backend/x86/regalloc.py
+++ b/rpython/jit/backend/x86/regalloc.py
@@ -22,7 +22,7 @@
from rpython.jit.codewriter.effectinfo import EffectInfo
from rpython.jit.metainterp.history import (Box, Const, ConstInt, ConstPtr,
ConstFloat, BoxInt, BoxFloat, INT, REF, FLOAT, TargetToken)
-from rpython.jit.metainterp.resoperation import rop
+from rpython.jit.metainterp.resoperation import rop, ResOperation
from rpython.rlib import rgc
from rpython.rlib.objectmodel import we_are_translated
from rpython.rlib.rarithmetic import r_longlong, r_uint
@@ -1332,6 +1332,13 @@
#if jump_op is not None and jump_op.getdescr() is descr:
# self._compute_hint_frame_locations_from_descr(descr)
+ def consider_guard_not_forced_2(self, op):
+ self.rm.before_call(op.getfailargs(), save_all_regs=True)
+ fail_locs = [self.loc(v) for v in op.getfailargs()]
+ self.assembler.store_force_descr(op, fail_locs,
+ self.fm.get_frame_depth())
+ self.possibly_free_vars(op.getfailargs())
+
def consider_keepalive(self, op):
pass
diff --git a/rpython/jit/codewriter/codewriter.py b/rpython/jit/codewriter/codewriter.py
--- a/rpython/jit/codewriter/codewriter.py
+++ b/rpython/jit/codewriter/codewriter.py
@@ -21,9 +21,9 @@
self.callcontrol = CallControl(cpu, jitdrivers_sd)
self._seen_files = set()
- def transform_func_to_jitcode(self, func, values, type_system='lltype'):
+ def transform_func_to_jitcode(self, func, values):
"""For testing."""
- rtyper = support.annotate(func, values, type_system=type_system)
+ rtyper = support.annotate(func, values)
graph = rtyper.annotator.translator.graphs[0]
jitcode = JitCode("test")
self.transform_graph_to_jitcode(graph, jitcode, True)
diff --git a/rpython/jit/codewriter/effectinfo.py b/rpython/jit/codewriter/effectinfo.py
--- a/rpython/jit/codewriter/effectinfo.py
+++ b/rpython/jit/codewriter/effectinfo.py
@@ -83,6 +83,7 @@
OS_UNI_COPY_TO_RAW = 113
OS_JIT_FORCE_VIRTUAL = 120
+ OS_JIT_FORCE_VIRTUALIZABLE = 121
# for debugging:
_OS_CANRAISE = set([
@@ -165,6 +166,9 @@
EffectInfo.MOST_GENERAL = EffectInfo(None, None, None, None,
EffectInfo.EF_RANDOM_EFFECTS,
can_invalidate=True)
+EffectInfo.LEAST_GENERAL = EffectInfo([], [], [], [],
+ EffectInfo.EF_ELIDABLE_CANNOT_RAISE,
+ can_invalidate=False)
def effectinfo_from_writeanalyze(effects, cpu,
diff --git a/rpython/jit/codewriter/jtransform.py b/rpython/jit/codewriter/jtransform.py
--- a/rpython/jit/codewriter/jtransform.py
+++ b/rpython/jit/codewriter/jtransform.py
@@ -521,6 +521,8 @@
op1 = SpaceOperation('str_guard_value', [op.args[0], c, descr],
op.result)
return [SpaceOperation('-live-', [], None), op1, None]
+ if hints.get('force_virtualizable'):
+ return SpaceOperation('hint_force_virtualizable', [op.args[0]], None)
else:
log.WARNING('ignoring hint %r at %r' % (hints, self.graph))
diff --git a/rpython/jit/codewriter/support.py b/rpython/jit/codewriter/support.py
--- a/rpython/jit/codewriter/support.py
+++ b/rpython/jit/codewriter/support.py
@@ -35,7 +35,7 @@
return a.typeannotation(t)
def annotate(func, values, inline=None, backendoptimize=True,
- type_system="lltype", translationoptions={}):
+ translationoptions={}):
# build the normal ll graphs for ll_function
t = TranslationContext()
for key, value in translationoptions.items():
@@ -44,7 +44,7 @@
a = t.buildannotator(policy=annpolicy)
argtypes = getargtypes(a, values)
a.build_types(func, argtypes, main_entry_point=True)
- rtyper = t.buildrtyper(type_system = type_system)
+ rtyper = t.buildrtyper()
rtyper.specialize()
#if inline:
# auto_inlining(t, threshold=inline)
diff --git a/rpython/jit/codewriter/test/test_flatten.py b/rpython/jit/codewriter/test/test_flatten.py
--- a/rpython/jit/codewriter/test/test_flatten.py
+++ b/rpython/jit/codewriter/test/test_flatten.py
@@ -125,8 +125,8 @@
class TestFlatten:
- def make_graphs(self, func, values, type_system='lltype'):
- self.rtyper = support.annotate(func, values, type_system=type_system)
+ def make_graphs(self, func, values):
+ self.rtyper = support.annotate(func, values)
return self.rtyper.annotator.translator.graphs
def encoding_test(self, func, args, expected,
diff --git a/rpython/jit/codewriter/test/test_policy.py b/rpython/jit/codewriter/test/test_policy.py
--- a/rpython/jit/codewriter/test/test_policy.py
+++ b/rpython/jit/codewriter/test/test_policy.py
@@ -131,7 +131,7 @@
def test_access_directly_but_not_seen():
class X:
- _virtualizable2_ = ["a"]
+ _virtualizable_ = ["a"]
def h(x, y):
w = 0
for i in range(y):
diff --git a/rpython/jit/codewriter/test/test_regalloc.py b/rpython/jit/codewriter/test/test_regalloc.py
--- a/rpython/jit/codewriter/test/test_regalloc.py
+++ b/rpython/jit/codewriter/test/test_regalloc.py
@@ -13,8 +13,8 @@
class TestRegAlloc:
- def make_graphs(self, func, values, type_system='lltype'):
- self.rtyper = support.annotate(func, values, type_system=type_system)
+ def make_graphs(self, func, values):
+ self.rtyper = support.annotate(func, values)
return self.rtyper.annotator.translator.graphs
def check_assembler(self, graph, expected, transform=False,
diff --git a/rpython/jit/metainterp/blackhole.py b/rpython/jit/metainterp/blackhole.py
--- a/rpython/jit/metainterp/blackhole.py
+++ b/rpython/jit/metainterp/blackhole.py
@@ -1320,6 +1320,10 @@
from rpython.jit.metainterp import quasiimmut
quasiimmut.do_force_quasi_immutable(cpu, struct, mutatefielddescr)
+ @arguments("r")
+ def bhimpl_hint_force_virtualizable(r):
+ pass
+
@arguments("cpu", "d", returns="r")
def bhimpl_new(cpu, descr):
return cpu.bh_new(descr)
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
@@ -708,6 +708,8 @@
rstack._stack_criticalcode_start()
try:
deadframe = cpu.force(token)
+ # this should set descr to ResumeGuardForceDescr, if it
+ # was not that already
faildescr = cpu.get_latest_descr(deadframe)
assert isinstance(faildescr, ResumeGuardForcedDescr)
faildescr.handle_async_forcing(deadframe)
@@ -715,12 +717,18 @@
rstack._stack_criticalcode_stop()
def handle_async_forcing(self, deadframe):
- from rpython.jit.metainterp.resume import force_from_resumedata
+ from rpython.jit.metainterp.resume import (force_from_resumedata,
+ AlreadyForced)
metainterp_sd = self.metainterp_sd
vinfo = self.jitdriver_sd.virtualizable_info
ginfo = self.jitdriver_sd.greenfield_info
- all_virtuals = force_from_resumedata(metainterp_sd, self, deadframe,
- vinfo, ginfo)
+ # there is some chance that this is already forced. In this case
+ # the virtualizable would have a token = NULL
+ try:
+ all_virtuals = force_from_resumedata(metainterp_sd, self, deadframe,
+ vinfo, ginfo)
+ except AlreadyForced:
+ return
# The virtualizable data was stored on the real virtualizable above.
# Handle all_virtuals: keep them for later blackholing from the
# future failure of the GUARD_NOT_FORCED
diff --git a/rpython/jit/metainterp/history.py b/rpython/jit/metainterp/history.py
--- a/rpython/jit/metainterp/history.py
+++ b/rpython/jit/metainterp/history.py
@@ -151,6 +151,8 @@
descr_ptr = cpu.ts.cast_to_baseclass(descr_gcref)
return cast_base_ptr_to_instance(AbstractDescr, descr_ptr)
+ def get_vinfo(self):
+ raise NotImplementedError
class AbstractFailDescr(AbstractDescr):
index = -1
diff --git a/rpython/jit/metainterp/jitexc.py b/rpython/jit/metainterp/jitexc.py
--- a/rpython/jit/metainterp/jitexc.py
+++ b/rpython/jit/metainterp/jitexc.py
@@ -62,7 +62,7 @@
def _get_standard_error(rtyper, Class):
- exdata = rtyper.getexceptiondata()
+ exdata = rtyper.exceptiondata
clsdef = rtyper.annotator.bookkeeper.getuniqueclassdef(Class)
evalue = exdata.get_standard_ll_exc_instance(rtyper, clsdef)
return evalue
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizebasic.py
@@ -5101,6 +5101,15 @@
}
self.optimize_loop(ops, expected, call_pure_results)
+ def test_guard_not_forced_2_virtual(self):
+ ops = """
+ [i0]
+ p0 = new_array(3, descr=arraydescr)
+ guard_not_forced_2() [p0]
+ finish(p0)
+ """
+ self.optimize_loop(ops, ops)
+
class TestLLtype(BaseTestOptimizeBasic, LLtypeMixin):
pass
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -7086,6 +7086,19 @@
"""
self.optimize_loop(ops, expected)
+ def test_force_virtualizable_virtual(self):
+ ops = """
+ [i0]
+ p1 = new_with_vtable(ConstClass(node_vtable))
+ cond_call(1, 123, p1, descr=clear_vable)
+ jump(i0)
+ """
+ expected = """
+ [i0]
+ jump(i0)
+ """
+ self.optimize_loop(ops, expected)
+
def test_setgetfield_counter(self):
ops = """
[p1]
diff --git a/rpython/jit/metainterp/optimizeopt/test/test_util.py b/rpython/jit/metainterp/optimizeopt/test/test_util.py
--- a/rpython/jit/metainterp/optimizeopt/test/test_util.py
+++ b/rpython/jit/metainterp/optimizeopt/test/test_util.py
@@ -254,12 +254,19 @@
asmdescr = LoopToken() # it can be whatever, it's not a descr though
from rpython.jit.metainterp.virtualref import VirtualRefInfo
+
class FakeWarmRunnerDesc:
pass
FakeWarmRunnerDesc.cpu = cpu
vrefinfo = VirtualRefInfo(FakeWarmRunnerDesc)
virtualtokendescr = vrefinfo.descr_virtual_token
virtualforceddescr = vrefinfo.descr_forced
+ FUNC = lltype.FuncType([], lltype.Void)
+ ei = EffectInfo([], [], [], [], EffectInfo.EF_CANNOT_RAISE,
+ can_invalidate=False,
+ oopspecindex=EffectInfo.OS_JIT_FORCE_VIRTUALIZABLE)
More information about the pypy-commit
mailing list