[pypy-commit] pypy reflex-support: merge default into branch
wlav
noreply at buildbot.pypy.org
Thu Jul 26 20:13:51 CEST 2012
Author: Wim Lavrijsen <WLavrijsen at lbl.gov>
Branch: reflex-support
Changeset: r56476:41c718c6dab7
Date: 2012-07-26 11:12 -0700
http://bitbucket.org/pypy/pypy/changeset/41c718c6dab7/
Log: merge default into branch
diff --git a/lib_pypy/pyrepl/readline.py b/lib_pypy/pyrepl/readline.py
--- a/lib_pypy/pyrepl/readline.py
+++ b/lib_pypy/pyrepl/readline.py
@@ -194,7 +194,7 @@
except _error:
return _old_raw_input(prompt)
reader.ps1 = prompt
- return reader.readline(reader, startup_hook=self.startup_hook)
+ return reader.readline(startup_hook=self.startup_hook)
def multiline_input(self, more_lines, ps1, ps2, returns_unicode=False):
"""Read an input on possibly multiple lines, asking for more
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
@@ -17,8 +17,15 @@
.. branch: iterator-in-rpython
.. branch: numpypy_count_nonzero
.. branch: even-more-jit-hooks
-
+Implement better JIT hooks
+.. branch: virtual-arguments
+Improve handling of **kwds greatly, making them virtual sometimes.
+.. branch: improve-rbigint
+Introduce __int128 on systems where it's supported and improve the speed of
+rlib/rbigint.py greatly.
.. "uninteresting" branches that we should just ignore for the whatsnew:
.. branch: slightly-shorter-c
.. branch: better-enforceargs
+.. branch: rpython-unicode-formatting
+.. branch: jit-opaque-licm
diff --git a/pypy/interpreter/argument.py b/pypy/interpreter/argument.py
--- a/pypy/interpreter/argument.py
+++ b/pypy/interpreter/argument.py
@@ -110,12 +110,10 @@
make_sure_not_resized(self.keywords_w)
make_sure_not_resized(self.arguments_w)
- if w_stararg is not None:
- self._combine_starargs_wrapped(w_stararg)
- # if we have a call where **args are used at the callsite
- # we shouldn't let the JIT see the argument matching
- self._dont_jit = (w_starstararg is not None and
- self._combine_starstarargs_wrapped(w_starstararg))
+ self._combine_wrapped(w_stararg, w_starstararg)
+ # a flag that specifies whether the JIT can unroll loops that operate
+ # on the keywords
+ self._jit_few_keywords = self.keywords is None or jit.isconstant(len(self.keywords))
def __repr__(self):
""" NOT_RPYTHON """
@@ -129,7 +127,7 @@
### Manipulation ###
- @jit.look_inside_iff(lambda self: not self._dont_jit)
+ @jit.look_inside_iff(lambda self: self._jit_few_keywords)
def unpack(self): # slowish
"Return a ([w1,w2...], {'kw':w3...}) pair."
kwds_w = {}
@@ -176,13 +174,14 @@
keywords, values_w = space.view_as_kwargs(w_starstararg)
if keywords is not None: # this path also taken for empty dicts
if self.keywords is None:
- self.keywords = keywords[:] # copy to make non-resizable
- self.keywords_w = values_w[:]
+ self.keywords = keywords
+ self.keywords_w = values_w
else:
- self._check_not_duplicate_kwargs(keywords, values_w)
+ _check_not_duplicate_kwargs(
+ self.space, self.keywords, keywords, values_w)
self.keywords = self.keywords + keywords
self.keywords_w = self.keywords_w + values_w
- return not jit.isconstant(len(self.keywords))
+ return
if space.isinstance_w(w_starstararg, space.w_dict):
keys_w = space.unpackiterable(w_starstararg)
else:
@@ -198,57 +197,17 @@
"a mapping, not %s" % (typename,)))
raise
keys_w = space.unpackiterable(w_keys)
- self._do_combine_starstarargs_wrapped(keys_w, w_starstararg)
- return True
-
- def _do_combine_starstarargs_wrapped(self, keys_w, w_starstararg):
- space = self.space
keywords_w = [None] * len(keys_w)
keywords = [None] * len(keys_w)
- i = 0
- for w_key in keys_w:
- try:
- key = space.str_w(w_key)
- except OperationError, e:
- if e.match(space, space.w_TypeError):
- raise OperationError(
- space.w_TypeError,
- space.wrap("keywords must be strings"))
- if e.match(space, space.w_UnicodeEncodeError):
- # Allow this to pass through
- key = None
- else:
- raise
- else:
- if self.keywords and key in self.keywords:
- raise operationerrfmt(self.space.w_TypeError,
- "got multiple values "
- "for keyword argument "
- "'%s'", key)
- keywords[i] = key
- keywords_w[i] = space.getitem(w_starstararg, w_key)
- i += 1
+ _do_combine_starstarargs_wrapped(space, keys_w, w_starstararg, keywords, keywords_w, self.keywords)
+ self.keyword_names_w = keys_w
if self.keywords is None:
self.keywords = keywords
self.keywords_w = keywords_w
else:
self.keywords = self.keywords + keywords
self.keywords_w = self.keywords_w + keywords_w
- self.keyword_names_w = keys_w
- @jit.look_inside_iff(lambda self, keywords, keywords_w:
- jit.isconstant(len(keywords) and
- jit.isconstant(self.keywords)))
- def _check_not_duplicate_kwargs(self, keywords, keywords_w):
- # looks quadratic, but the JIT should remove all of it nicely.
- # Also, all the lists should be small
- for key in keywords:
- for otherkey in self.keywords:
- if otherkey == key:
- raise operationerrfmt(self.space.w_TypeError,
- "got multiple values "
- "for keyword argument "
- "'%s'", key)
def fixedunpack(self, argcount):
"""The simplest argument parsing: get the 'argcount' arguments,
@@ -269,34 +228,14 @@
### Parsing for function calls ###
- # XXX: this should be @jit.look_inside_iff, but we need key word arguments,
- # and it doesn't support them for now.
+ @jit.unroll_safe
def _match_signature(self, w_firstarg, scope_w, signature, defaults_w=None,
blindargs=0):
"""Parse args and kwargs according to the signature of a code object,
or raise an ArgErr in case of failure.
- Return the number of arguments filled in.
"""
- if jit.we_are_jitted() and self._dont_jit:
- return self._match_signature_jit_opaque(w_firstarg, scope_w,
- signature, defaults_w,
- blindargs)
- return self._really_match_signature(w_firstarg, scope_w, signature,
- defaults_w, blindargs)
-
- @jit.dont_look_inside
- def _match_signature_jit_opaque(self, w_firstarg, scope_w, signature,
- defaults_w, blindargs):
- return self._really_match_signature(w_firstarg, scope_w, signature,
- defaults_w, blindargs)
-
- @jit.unroll_safe
- def _really_match_signature(self, w_firstarg, scope_w, signature,
- defaults_w=None, blindargs=0):
- #
+ # w_firstarg = a first argument to be inserted (e.g. self) or None
# args_w = list of the normal actual parameters, wrapped
- # kwds_w = real dictionary {'keyword': wrapped parameter}
- # argnames = list of formal parameter names
# scope_w = resulting list of wrapped values
#
@@ -304,38 +243,29 @@
# so all values coming from there can be assumed constant. It assumes
# that the length of the defaults_w does not vary too much.
co_argcount = signature.num_argnames() # expected formal arguments, without */**
- has_vararg = signature.has_vararg()
- has_kwarg = signature.has_kwarg()
- extravarargs = None
- input_argcount = 0
+ # put the special w_firstarg into the scope, if it exists
if w_firstarg is not None:
upfront = 1
if co_argcount > 0:
scope_w[0] = w_firstarg
- input_argcount = 1
- else:
- extravarargs = [w_firstarg]
else:
upfront = 0
args_w = self.arguments_w
num_args = len(args_w)
+ avail = num_args + upfront
keywords = self.keywords
- keywords_w = self.keywords_w
num_kwds = 0
if keywords is not None:
num_kwds = len(keywords)
- avail = num_args + upfront
+ # put as many positional input arguments into place as available
+ input_argcount = upfront
if input_argcount < co_argcount:
- # put as many positional input arguments into place as available
- if avail > co_argcount:
- take = co_argcount - input_argcount
- else:
- take = num_args
+ take = min(num_args, co_argcount - upfront)
# letting the JIT unroll this loop is safe, because take is always
# smaller than co_argcount
@@ -344,11 +274,10 @@
input_argcount += take
# collect extra positional arguments into the *vararg
- if has_vararg:
+ if signature.has_vararg():
args_left = co_argcount - upfront
if args_left < 0: # check required by rpython
- assert extravarargs is not None
- starargs_w = extravarargs
+ starargs_w = [w_firstarg]
if num_args:
starargs_w = starargs_w + args_w
elif num_args > args_left:
@@ -357,86 +286,68 @@
starargs_w = []
scope_w[co_argcount] = self.space.newtuple(starargs_w)
elif avail > co_argcount:
- raise ArgErrCount(avail, num_kwds,
- co_argcount, has_vararg, has_kwarg,
- defaults_w, 0)
+ raise ArgErrCount(avail, num_kwds, signature, defaults_w, 0)
- # the code assumes that keywords can potentially be large, but that
- # argnames is typically not too large
- num_remainingkwds = num_kwds
- used_keywords = None
- if keywords:
- # letting JIT unroll the loop is *only* safe if the callsite didn't
- # use **args because num_kwds can be arbitrarily large otherwise.
- used_keywords = [False] * num_kwds
- for i in range(num_kwds):
- name = keywords[i]
- # If name was not encoded as a string, it could be None. In that
- # case, it's definitely not going to be in the signature.
- if name is None:
- continue
- j = signature.find_argname(name)
- if j < 0:
- continue
- elif j < input_argcount:
- # check that no keyword argument conflicts with these. note
- # that for this purpose we ignore the first blindargs,
- # which were put into place by prepend(). This way,
- # keywords do not conflict with the hidden extra argument
- # bound by methods.
- if blindargs <= j:
- raise ArgErrMultipleValues(name)
+ # if a **kwargs argument is needed, create the dict
+ w_kwds = None
+ if signature.has_kwarg():
+ w_kwds = self.space.newdict(kwargs=True)
+ scope_w[co_argcount + signature.has_vararg()] = w_kwds
+
+ # handle keyword arguments
+ num_remainingkwds = 0
+ keywords_w = self.keywords_w
+ kwds_mapping = None
+ if num_kwds:
+ # kwds_mapping maps target indexes in the scope (minus input_argcount)
+ # to positions in the keywords_w list
+ cnt = (co_argcount - input_argcount)
+ if cnt < 0:
+ cnt = 0
+ kwds_mapping = [0] * cnt
+ # initialize manually, for the JIT :-(
+ for i in range(len(kwds_mapping)):
+ kwds_mapping[i] = -1
+ # match the keywords given at the call site to the argument names
+ # the called function takes
+ # this function must not take a scope_w, to make the scope not
+ # escape
+ num_remainingkwds = _match_keywords(
+ signature, blindargs, input_argcount, keywords,
+ kwds_mapping, self._jit_few_keywords)
+ if num_remainingkwds:
+ if w_kwds is not None:
+ # collect extra keyword arguments into the **kwarg
+ _collect_keyword_args(
+ self.space, keywords, keywords_w, w_kwds,
+ kwds_mapping, self.keyword_names_w, self._jit_few_keywords)
else:
- assert scope_w[j] is None
- scope_w[j] = keywords_w[i]
- used_keywords[i] = True # mark as used
- num_remainingkwds -= 1
+ if co_argcount == 0:
+ raise ArgErrCount(avail, num_kwds, signature, defaults_w, 0)
+ raise ArgErrUnknownKwds(self.space, num_remainingkwds, keywords,
+ kwds_mapping, self.keyword_names_w)
+
+ # check for missing arguments and fill them from the kwds,
+ # or with defaults, if available
missing = 0
if input_argcount < co_argcount:
def_first = co_argcount - (0 if defaults_w is None else len(defaults_w))
+ j = 0
+ kwds_index = -1
for i in range(input_argcount, co_argcount):
- if scope_w[i] is not None:
- continue
+ if kwds_mapping is not None:
+ kwds_index = kwds_mapping[j]
+ j += 1
+ if kwds_index >= 0:
+ scope_w[i] = keywords_w[kwds_index]
+ continue
defnum = i - def_first
if defnum >= 0:
scope_w[i] = defaults_w[defnum]
else:
- # error: not enough arguments. Don't signal it immediately
- # because it might be related to a problem with */** or
- # keyword arguments, which will be checked for below.
missing += 1
-
- # collect extra keyword arguments into the **kwarg
- if has_kwarg:
- w_kwds = self.space.newdict(kwargs=True)
- if num_remainingkwds:
- #
- limit = len(keywords)
- if self.keyword_names_w is not None:
- limit -= len(self.keyword_names_w)
- for i in range(len(keywords)):
- if not used_keywords[i]:
- if i < limit:
- w_key = self.space.wrap(keywords[i])
- else:
- w_key = self.keyword_names_w[i - limit]
- self.space.setitem(w_kwds, w_key, keywords_w[i])
- #
- scope_w[co_argcount + has_vararg] = w_kwds
- elif num_remainingkwds:
- if co_argcount == 0:
- raise ArgErrCount(avail, num_kwds,
- co_argcount, has_vararg, has_kwarg,
- defaults_w, missing)
- raise ArgErrUnknownKwds(self.space, num_remainingkwds, keywords,
- used_keywords, self.keyword_names_w)
-
- if missing:
- raise ArgErrCount(avail, num_kwds,
- co_argcount, has_vararg, has_kwarg,
- defaults_w, missing)
-
- return co_argcount + has_vararg + has_kwarg
+ if missing:
+ raise ArgErrCount(avail, num_kwds, signature, defaults_w, missing)
@@ -448,11 +359,12 @@
scope_w must be big enough for signature.
"""
try:
- return self._match_signature(w_firstarg,
- scope_w, signature, defaults_w, 0)
+ self._match_signature(w_firstarg,
+ scope_w, signature, defaults_w, 0)
except ArgErr, e:
raise operationerrfmt(self.space.w_TypeError,
"%s() %s", fnname, e.getmsg())
+ return signature.scope_length()
def _parse(self, w_firstarg, signature, defaults_w, blindargs=0):
"""Parse args and kwargs according to the signature of a code object,
@@ -499,6 +411,102 @@
space.setitem(w_kwds, w_key, self.keywords_w[i])
return w_args, w_kwds
+# JIT helper functions
+# these functions contain functionality that the JIT is not always supposed to
+# look at. They should not get a self arguments, which makes the amount of
+# arguments annoying :-(
+
+ at jit.look_inside_iff(lambda space, existingkeywords, keywords, keywords_w:
+ jit.isconstant(len(keywords) and
+ jit.isconstant(existingkeywords)))
+def _check_not_duplicate_kwargs(space, existingkeywords, keywords, keywords_w):
+ # looks quadratic, but the JIT should remove all of it nicely.
+ # Also, all the lists should be small
+ for key in keywords:
+ for otherkey in existingkeywords:
+ if otherkey == key:
+ raise operationerrfmt(space.w_TypeError,
+ "got multiple values "
+ "for keyword argument "
+ "'%s'", key)
+
+def _do_combine_starstarargs_wrapped(space, keys_w, w_starstararg, keywords,
+ keywords_w, existingkeywords):
+ i = 0
+ for w_key in keys_w:
+ try:
+ key = space.str_w(w_key)
+ except OperationError, e:
+ if e.match(space, space.w_TypeError):
+ raise OperationError(
+ space.w_TypeError,
+ space.wrap("keywords must be strings"))
+ if e.match(space, space.w_UnicodeEncodeError):
+ # Allow this to pass through
+ key = None
+ else:
+ raise
+ else:
+ if existingkeywords and key in existingkeywords:
+ raise operationerrfmt(space.w_TypeError,
+ "got multiple values "
+ "for keyword argument "
+ "'%s'", key)
+ keywords[i] = key
+ keywords_w[i] = space.getitem(w_starstararg, w_key)
+ i += 1
+
+ at jit.look_inside_iff(
+ lambda signature, blindargs, input_argcount,
+ keywords, kwds_mapping, jiton: jiton)
+def _match_keywords(signature, blindargs, input_argcount,
+ keywords, kwds_mapping, _):
+ # letting JIT unroll the loop is *only* safe if the callsite didn't
+ # use **args because num_kwds can be arbitrarily large otherwise.
+ num_kwds = num_remainingkwds = len(keywords)
+ for i in range(num_kwds):
+ name = keywords[i]
+ # If name was not encoded as a string, it could be None. In that
+ # case, it's definitely not going to be in the signature.
+ if name is None:
+ continue
+ j = signature.find_argname(name)
+ # if j == -1 nothing happens, because j < input_argcount and
+ # blindargs > j
+ if j < input_argcount:
+ # check that no keyword argument conflicts with these. note
+ # that for this purpose we ignore the first blindargs,
+ # which were put into place by prepend(). This way,
+ # keywords do not conflict with the hidden extra argument
+ # bound by methods.
+ if blindargs <= j:
+ raise ArgErrMultipleValues(name)
+ else:
+ kwds_mapping[j - input_argcount] = i # map to the right index
+ num_remainingkwds -= 1
+ return num_remainingkwds
+
+ at jit.look_inside_iff(
+ lambda space, keywords, keywords_w, w_kwds, kwds_mapping,
+ keyword_names_w, jiton: jiton)
+def _collect_keyword_args(space, keywords, keywords_w, w_kwds, kwds_mapping,
+ keyword_names_w, _):
+ limit = len(keywords)
+ if keyword_names_w is not None:
+ limit -= len(keyword_names_w)
+ for i in range(len(keywords)):
+ # again a dangerous-looking loop that either the JIT unrolls
+ # or that is not too bad, because len(kwds_mapping) is small
+ for j in kwds_mapping:
+ if i == j:
+ break
+ else:
+ if i < limit:
+ w_key = space.wrap(keywords[i])
+ else:
+ w_key = keyword_names_w[i - limit]
+ space.setitem(w_kwds, w_key, keywords_w[i])
+
class ArgumentsForTranslation(Arguments):
def __init__(self, space, args_w, keywords=None, keywords_w=None,
w_stararg=None, w_starstararg=None):
@@ -654,11 +662,9 @@
class ArgErrCount(ArgErr):
- def __init__(self, got_nargs, nkwds, expected_nargs, has_vararg, has_kwarg,
+ def __init__(self, got_nargs, nkwds, signature,
defaults_w, missing_args):
- self.expected_nargs = expected_nargs
- self.has_vararg = has_vararg
- self.has_kwarg = has_kwarg
+ self.signature = signature
self.num_defaults = 0 if defaults_w is None else len(defaults_w)
self.missing_args = missing_args
@@ -666,16 +672,16 @@
self.num_kwds = nkwds
def getmsg(self):
- n = self.expected_nargs
+ n = self.signature.num_argnames()
if n == 0:
msg = "takes no arguments (%d given)" % (
self.num_args + self.num_kwds)
else:
defcount = self.num_defaults
- has_kwarg = self.has_kwarg
+ has_kwarg = self.signature.has_kwarg()
num_args = self.num_args
num_kwds = self.num_kwds
- if defcount == 0 and not self.has_vararg:
+ if defcount == 0 and not self.signature.has_vararg():
msg1 = "exactly"
if not has_kwarg:
num_args += num_kwds
@@ -714,13 +720,13 @@
class ArgErrUnknownKwds(ArgErr):
- def __init__(self, space, num_remainingkwds, keywords, used_keywords,
+ def __init__(self, space, num_remainingkwds, keywords, kwds_mapping,
keyword_names_w):
name = ''
self.num_kwds = num_remainingkwds
if num_remainingkwds == 1:
for i in range(len(keywords)):
- if not used_keywords[i]:
+ if i not in kwds_mapping:
name = keywords[i]
if name is None:
# We'll assume it's unicode. Encode it.
diff --git a/pypy/interpreter/test/test_argument.py b/pypy/interpreter/test/test_argument.py
--- a/pypy/interpreter/test/test_argument.py
+++ b/pypy/interpreter/test/test_argument.py
@@ -57,6 +57,9 @@
def __nonzero__(self):
raise NotImplementedError
+class kwargsdict(dict):
+ pass
+
class DummySpace(object):
def newtuple(self, items):
return tuple(items)
@@ -76,9 +79,13 @@
return list(it)
def view_as_kwargs(self, x):
+ if len(x) == 0:
+ return [], []
return None, None
def newdict(self, kwargs=False):
+ if kwargs:
+ return kwargsdict()
return {}
def newlist(self, l=[]):
@@ -299,6 +306,22 @@
args._match_signature(None, l, Signature(["a", "b", "c"], None, "**"))
assert l == [1, 2, 3, {'d': 4}]
+ def test_match_kwds_creates_kwdict(self):
+ space = DummySpace()
+ kwds = [("c", 3), ('d', 4)]
+ for i in range(4):
+ kwds_w = dict(kwds[:i])
+ keywords = kwds_w.keys()
+ keywords_w = kwds_w.values()
+ w_kwds = dummy_wrapped_dict(kwds[i:])
+ if i == 3:
+ w_kwds = None
+ args = Arguments(space, [1, 2], keywords, keywords_w, w_starstararg=w_kwds)
+ l = [None, None, None, None]
+ args._match_signature(None, l, Signature(["a", "b", "c"], None, "**"))
+ assert l == [1, 2, 3, {'d': 4}]
+ assert isinstance(l[-1], kwargsdict)
+
def test_duplicate_kwds(self):
space = DummySpace()
excinfo = py.test.raises(OperationError, Arguments, space, [], ["a"],
@@ -546,34 +569,47 @@
def test_missing_args(self):
# got_nargs, nkwds, expected_nargs, has_vararg, has_kwarg,
# defaults_w, missing_args
- err = ArgErrCount(1, 0, 0, False, False, None, 0)
+ sig = Signature([], None, None)
+ err = ArgErrCount(1, 0, sig, None, 0)
s = err.getmsg()
assert s == "takes no arguments (1 given)"
- err = ArgErrCount(0, 0, 1, False, False, [], 1)
+
+ sig = Signature(['a'], None, None)
+ err = ArgErrCount(0, 0, sig, [], 1)
s = err.getmsg()
assert s == "takes exactly 1 argument (0 given)"
- err = ArgErrCount(3, 0, 2, False, False, [], 0)
+
+ sig = Signature(['a', 'b'], None, None)
+ err = ArgErrCount(3, 0, sig, [], 0)
s = err.getmsg()
assert s == "takes exactly 2 arguments (3 given)"
- err = ArgErrCount(3, 0, 2, False, False, ['a'], 0)
+ err = ArgErrCount(3, 0, sig, ['a'], 0)
s = err.getmsg()
assert s == "takes at most 2 arguments (3 given)"
- err = ArgErrCount(1, 0, 2, True, False, [], 1)
+
+ sig = Signature(['a', 'b'], '*', None)
+ err = ArgErrCount(1, 0, sig, [], 1)
s = err.getmsg()
assert s == "takes at least 2 arguments (1 given)"
- err = ArgErrCount(0, 1, 2, True, False, ['a'], 1)
+ err = ArgErrCount(0, 1, sig, ['a'], 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
- err = ArgErrCount(2, 1, 1, False, True, [], 0)
+
+ sig = Signature(['a'], None, '**')
+ err = ArgErrCount(2, 1, sig, [], 0)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (2 given)"
- err = ArgErrCount(0, 1, 1, False, True, [], 1)
+ err = ArgErrCount(0, 1, sig, [], 1)
s = err.getmsg()
assert s == "takes exactly 1 non-keyword argument (0 given)"
- err = ArgErrCount(0, 1, 1, True, True, [], 1)
+
+ sig = Signature(['a'], '*', '**')
+ err = ArgErrCount(0, 1, sig, [], 1)
s = err.getmsg()
assert s == "takes at least 1 non-keyword argument (0 given)"
- err = ArgErrCount(2, 1, 1, False, True, ['a'], 0)
+
+ sig = Signature(['a'], None, '**')
+ err = ArgErrCount(2, 1, sig, ['a'], 0)
s = err.getmsg()
assert s == "takes at most 1 non-keyword argument (2 given)"
@@ -596,11 +632,14 @@
def test_unknown_keywords(self):
space = DummySpace()
- err = ArgErrUnknownKwds(space, 1, ['a', 'b'], [True, False], None)
+ err = ArgErrUnknownKwds(space, 1, ['a', 'b'], [0], None)
s = err.getmsg()
assert s == "got an unexpected keyword argument 'b'"
+ err = ArgErrUnknownKwds(space, 1, ['a', 'b'], [1], None)
+ s = err.getmsg()
+ assert s == "got an unexpected keyword argument 'a'"
err = ArgErrUnknownKwds(space, 2, ['a', 'b', 'c'],
- [True, False, False], None)
+ [0], None)
s = err.getmsg()
assert s == "got 2 unexpected keyword arguments"
@@ -610,7 +649,7 @@
defaultencoding = 'utf-8'
space = DummySpaceUnicode()
err = ArgErrUnknownKwds(space, 1, ['a', None, 'b', 'c'],
- [True, False, True, True],
+ [0, 3, 2],
[unichr(0x1234), u'b', u'c'])
s = err.getmsg()
assert s == "got an unexpected keyword argument '\xe1\x88\xb4'"
diff --git a/pypy/jit/backend/llgraph/llimpl.py b/pypy/jit/backend/llgraph/llimpl.py
--- a/pypy/jit/backend/llgraph/llimpl.py
+++ b/pypy/jit/backend/llgraph/llimpl.py
@@ -96,6 +96,7 @@
'int_add_ovf' : (('int', 'int'), 'int'),
'int_sub_ovf' : (('int', 'int'), 'int'),
'int_mul_ovf' : (('int', 'int'), 'int'),
+ 'int_force_ge_zero':(('int',), 'int'),
'uint_add' : (('int', 'int'), 'int'),
'uint_sub' : (('int', 'int'), 'int'),
'uint_mul' : (('int', 'int'), 'int'),
@@ -1522,6 +1523,7 @@
def do_new_array(arraynum, count):
TYPE = symbolic.Size2Type[arraynum]
+ assert count >= 0 # explode if it's not
x = lltype.malloc(TYPE, count, zero=True)
return cast_to_ptr(x)
diff --git a/pypy/jit/backend/x86/assembler.py b/pypy/jit/backend/x86/assembler.py
--- a/pypy/jit/backend/x86/assembler.py
+++ b/pypy/jit/backend/x86/assembler.py
@@ -1375,6 +1375,11 @@
genop_cast_ptr_to_int = genop_same_as
genop_cast_int_to_ptr = genop_same_as
+ def genop_int_force_ge_zero(self, op, arglocs, resloc):
+ self.mc.TEST(arglocs[0], arglocs[0])
+ self.mov(imm0, resloc)
+ self.mc.CMOVNS(arglocs[0], resloc)
+
def genop_int_mod(self, op, arglocs, resloc):
if IS_X86_32:
self.mc.CDQ()
diff --git a/pypy/jit/backend/x86/regalloc.py b/pypy/jit/backend/x86/regalloc.py
--- a/pypy/jit/backend/x86/regalloc.py
+++ b/pypy/jit/backend/x86/regalloc.py
@@ -1188,6 +1188,12 @@
consider_cast_ptr_to_int = consider_same_as
consider_cast_int_to_ptr = consider_same_as
+ def consider_int_force_ge_zero(self, op):
+ argloc = self.make_sure_var_in_reg(op.getarg(0))
+ resloc = self.force_allocate_reg(op.result, [op.getarg(0)])
+ self.possibly_free_var(op.getarg(0))
+ self.Perform(op, [argloc], resloc)
+
def consider_strlen(self, op):
args = op.getarglist()
base_loc = self.rm.make_sure_var_in_reg(op.getarg(0), args)
diff --git a/pypy/jit/backend/x86/regloc.py b/pypy/jit/backend/x86/regloc.py
--- a/pypy/jit/backend/x86/regloc.py
+++ b/pypy/jit/backend/x86/regloc.py
@@ -548,6 +548,7 @@
# Avoid XCHG because it always implies atomic semantics, which is
# slower and does not pair well for dispatch.
#XCHG = _binaryop('XCHG')
+ CMOVNS = _binaryop('CMOVNS')
PUSH = _unaryop('PUSH')
POP = _unaryop('POP')
diff --git a/pypy/jit/backend/x86/rx86.py b/pypy/jit/backend/x86/rx86.py
--- a/pypy/jit/backend/x86/rx86.py
+++ b/pypy/jit/backend/x86/rx86.py
@@ -530,6 +530,8 @@
NOT_r = insn(rex_w, '\xF7', register(1), '\xD0')
NOT_b = insn(rex_w, '\xF7', orbyte(2<<3), stack_bp(1))
+ CMOVNS_rr = insn(rex_w, '\x0F\x49', register(2, 8), register(1), '\xC0')
+
# ------------------------------ Misc stuff ------------------------------
NOP = insn('\x90')
diff --git a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
--- a/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
+++ b/pypy/jit/backend/x86/test/test_rx86_32_auto_encoding.py
@@ -317,7 +317,9 @@
# CALL_j is actually relative, so tricky to test
(instrname == 'CALL' and argmodes == 'j') or
# SET_ir must be tested manually
- (instrname == 'SET' and argmodes == 'ir')
+ (instrname == 'SET' and argmodes == 'ir') or
+ # asm gets CMOVNS args the wrong way
+ (instrname.startswith('CMOV'))
)
diff --git a/pypy/jit/backend/x86/test/test_ztranslation.py b/pypy/jit/backend/x86/test/test_ztranslation.py
--- a/pypy/jit/backend/x86/test/test_ztranslation.py
+++ b/pypy/jit/backend/x86/test/test_ztranslation.py
@@ -181,6 +181,7 @@
i += 1
def main():
+ jit_hooks.stats_set_debug(None, True)
f()
ll_times = jit_hooks.stats_get_loop_run_times(None)
return len(ll_times)
diff --git a/pypy/jit/codewriter/jtransform.py b/pypy/jit/codewriter/jtransform.py
--- a/pypy/jit/codewriter/jtransform.py
+++ b/pypy/jit/codewriter/jtransform.py
@@ -1430,7 +1430,19 @@
def do_fixed_newlist(self, op, args, arraydescr):
v_length = self._get_initial_newlist_length(op, args)
- return SpaceOperation('new_array', [arraydescr, v_length], op.result)
+ assert v_length.concretetype is lltype.Signed
+ ops = []
+ if isinstance(v_length, Constant):
+ if v_length.value >= 0:
+ v = v_length
+ else:
+ v = Constant(0, lltype.Signed)
+ else:
+ v = Variable('new_length')
+ v.concretetype = lltype.Signed
+ ops.append(SpaceOperation('int_force_ge_zero', [v_length], v))
+ ops.append(SpaceOperation('new_array', [arraydescr, v], op.result))
+ return ops
def do_fixed_list_len(self, op, args, arraydescr):
if args[0] in self.vable_array_vars: # virtualizable array
diff --git a/pypy/jit/codewriter/test/test_codewriter.py b/pypy/jit/codewriter/test/test_codewriter.py
--- a/pypy/jit/codewriter/test/test_codewriter.py
+++ b/pypy/jit/codewriter/test/test_codewriter.py
@@ -221,3 +221,17 @@
assert 'setarrayitem_raw_i' in s
assert 'getarrayitem_raw_i' in s
assert 'residual_call_ir_v $<* fn _ll_1_raw_free__arrayPtr>' in s
+
+def test_newlist_negativ():
+ def f(n):
+ l = [0] * n
+ return len(l)
+
+ rtyper = support.annotate(f, [-1])
+ jitdriver_sd = FakeJitDriverSD(rtyper.annotator.translator.graphs[0])
+ cw = CodeWriter(FakeCPU(rtyper), [jitdriver_sd])
+ cw.find_all_graphs(FakePolicy())
+ cw.make_jitcodes(verbose=True)
+ s = jitdriver_sd.mainjitcode.dump()
+ assert 'int_force_ge_zero' in s
+ assert 'new_array' in s
diff --git a/pypy/jit/codewriter/test/test_list.py b/pypy/jit/codewriter/test/test_list.py
--- a/pypy/jit/codewriter/test/test_list.py
+++ b/pypy/jit/codewriter/test/test_list.py
@@ -85,8 +85,11 @@
"""new_array <ArrayDescr>, $0 -> %r0""")
builtin_test('newlist', [Constant(5, lltype.Signed)], FIXEDLIST,
"""new_array <ArrayDescr>, $5 -> %r0""")
+ builtin_test('newlist', [Constant(-2, lltype.Signed)], FIXEDLIST,
+ """new_array <ArrayDescr>, $0 -> %r0""")
builtin_test('newlist', [varoftype(lltype.Signed)], FIXEDLIST,
- """new_array <ArrayDescr>, %i0 -> %r0""")
+ """int_force_ge_zero %i0 -> %i1\n"""
+ """new_array <ArrayDescr>, %i1 -> %r0""")
builtin_test('newlist', [Constant(5, lltype.Signed),
Constant(0, lltype.Signed)], FIXEDLIST,
"""new_array <ArrayDescr>, $5 -> %r0""")
diff --git a/pypy/jit/metainterp/blackhole.py b/pypy/jit/metainterp/blackhole.py
--- a/pypy/jit/metainterp/blackhole.py
+++ b/pypy/jit/metainterp/blackhole.py
@@ -477,6 +477,11 @@
@arguments("i", "i", "i", returns="i")
def bhimpl_int_between(a, b, c):
return a <= b < c
+ @arguments("i", returns="i")
+ def bhimpl_int_force_ge_zero(i):
+ if i < 0:
+ return 0
+ return i
@arguments("i", "i", returns="i")
def bhimpl_uint_lt(a, b):
diff --git a/pypy/jit/metainterp/optimizeopt/heap.py b/pypy/jit/metainterp/optimizeopt/heap.py
--- a/pypy/jit/metainterp/optimizeopt/heap.py
+++ b/pypy/jit/metainterp/optimizeopt/heap.py
@@ -1,7 +1,7 @@
import os
from pypy.jit.metainterp.jitexc import JitException
-from pypy.jit.metainterp.optimizeopt.optimizer import Optimization, MODE_ARRAY
+from pypy.jit.metainterp.optimizeopt.optimizer import Optimization, MODE_ARRAY, LEVEL_KNOWNCLASS
from pypy.jit.metainterp.history import ConstInt, Const
from pypy.jit.metainterp.optimizeopt.util import make_dispatcher_method
from pypy.jit.metainterp.resoperation import rop, ResOperation
@@ -128,8 +128,12 @@
op = self._cached_fields_getfield_op[structvalue]
if not op:
continue
- if optimizer.getvalue(op.getarg(0)) in optimizer.opaque_pointers:
- continue
+ value = optimizer.getvalue(op.getarg(0))
+ if value in optimizer.opaque_pointers:
+ if value.level < LEVEL_KNOWNCLASS:
+ continue
+ if op.getopnum() != rop.SETFIELD_GC and op.getopnum() != rop.GETFIELD_GC:
+ continue
if structvalue in self._cached_fields:
if op.getopnum() == rop.SETFIELD_GC:
result = op.getarg(1)
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_multilabel.py b/pypy/jit/metainterp/optimizeopt/test/test_multilabel.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_multilabel.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_multilabel.py
@@ -431,7 +431,53 @@
jump(i55, i81)
"""
self.optimize_loop(ops, expected)
-
+
+ def test_boxed_opaque_unknown_class(self):
+ ops = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p2)
+ i3 = getfield_gc(p2, descr=otherdescr)
+ label(p1)
+ i4 = getfield_gc(p1, descr=otherdescr)
+ label(p1)
+ p5 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p5)
+ i6 = getfield_gc(p5, descr=otherdescr)
+ i7 = call(i6, descr=nonwritedescr)
+ """
+ expected = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ i3 = getfield_gc(p2, descr=otherdescr)
+ label(p1)
+ i4 = getfield_gc(p1, descr=otherdescr)
+ label(p1)
+ p5 = getfield_gc(p1, descr=nextdescr)
+ i6 = getfield_gc(p5, descr=otherdescr)
+ i7 = call(i6, descr=nonwritedescr)
+ """
+ self.optimize_loop(ops, expected)
+
+ def test_opaque_pointer_fails_to_close_loop(self):
+ ops = """
+ [p1, p11]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ guard_class(p2, ConstClass(node_vtable)) []
+ mark_opaque_ptr(p2)
+ i3 = getfield_gc(p2, descr=otherdescr)
+ label(p1, p11)
+ p12 = getfield_gc(p1, descr=nextdescr)
+ i13 = getfield_gc(p2, descr=otherdescr)
+ i14 = call(i13, descr=nonwritedescr)
+ jump(p11, p1)
+ """
+ with raises(InvalidLoop):
+ self.optimize_loop(ops, ops)
+
+
+
+
class OptRenameStrlen(Optimization):
def propagate_forward(self, op):
dispatch_opt(self, op)
diff --git a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
--- a/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
+++ b/pypy/jit/metainterp/optimizeopt/test/test_optimizeopt.py
@@ -7872,6 +7872,73 @@
self.raises(InvalidLoop, self.optimize_loop,
ops, ops)
+ def test_licm_boxed_opaque_getitem(self):
+ ops = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p2)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1)
+ """
+ expected = """
+ [p1, i3]
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1, i3)
+ """
+ self.optimize_loop(ops, expected)
+
+ def test_licm_boxed_opaque_getitem_unknown_class(self):
+ ops = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p2)
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1)
+ """
+ expected = """
+ [p1, p2]
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1, p2)
+ """
+ self.optimize_loop(ops, expected)
+
+ def test_licm_unboxed_opaque_getitem(self):
+ ops = """
+ [p2]
+ mark_opaque_ptr(p2)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p2)
+ """
+ expected = """
+ [p1, i3]
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1, i3)
+ """
+ self.optimize_loop(ops, expected)
+
+ def test_licm_unboxed_opaque_getitem_unknown_class(self):
+ ops = """
+ [p2]
+ mark_opaque_ptr(p2)
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p2)
+ """
+ expected = """
+ [p2]
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p2)
+ """
+ self.optimize_loop(ops, expected)
+
+
class TestLLtype(OptimizeOptTest, LLtypeMixin):
pass
diff --git a/pypy/jit/metainterp/optimizeopt/unroll.py b/pypy/jit/metainterp/optimizeopt/unroll.py
--- a/pypy/jit/metainterp/optimizeopt/unroll.py
+++ b/pypy/jit/metainterp/optimizeopt/unroll.py
@@ -341,6 +341,12 @@
op = self.short[i]
newop = self.short_inliner.inline_op(op)
self.optimizer.send_extra_operation(newop)
+ if op.result in self.short_boxes.assumed_classes:
+ classbox = self.getvalue(newop.result).get_constant_class(self.optimizer.cpu)
+ assumed_classbox = self.short_boxes.assumed_classes[op.result]
+ if not classbox or not classbox.same_constant(assumed_classbox):
+ raise InvalidLoop('Class of opaque pointer needed in short ' +
+ 'preamble unknown at end of loop')
i += 1
# Import boxes produced in the preamble but used in the loop
@@ -432,9 +438,13 @@
newargs[i] = a.clonebox()
boxmap[a] = newargs[i]
inliner = Inliner(short_inputargs, newargs)
+ target_token.assumed_classes = {}
for i in range(len(short)):
- short[i] = inliner.inline_op(short[i])
-
+ op = short[i]
+ newop = inliner.inline_op(op)
+ if op.result and op.result in self.short_boxes.assumed_classes:
+ target_token.assumed_classes[newop.result] = self.short_boxes.assumed_classes[op.result]
+ short[i] = newop
target_token.resume_at_jump_descr = target_token.resume_at_jump_descr.clone_if_mutable()
inliner.inline_descr_inplace(target_token.resume_at_jump_descr)
@@ -588,6 +598,12 @@
for shop in target.short_preamble[1:]:
newop = inliner.inline_op(shop)
self.optimizer.send_extra_operation(newop)
+ if shop.result in target.assumed_classes:
+ classbox = self.getvalue(newop.result).get_constant_class(self.optimizer.cpu)
+ if not classbox or not classbox.same_constant(target.assumed_classes[shop.result]):
+ raise InvalidLoop('The class of an opaque pointer at the end ' +
+ 'of the bridge does not mach the class ' +
+ 'it has at the start of the target loop')
except InvalidLoop:
#debug_print("Inlining failed unexpectedly",
# "jumping to preamble instead")
diff --git a/pypy/jit/metainterp/optimizeopt/virtualstate.py b/pypy/jit/metainterp/optimizeopt/virtualstate.py
--- a/pypy/jit/metainterp/optimizeopt/virtualstate.py
+++ b/pypy/jit/metainterp/optimizeopt/virtualstate.py
@@ -288,7 +288,8 @@
class NotVirtualStateInfo(AbstractVirtualStateInfo):
- def __init__(self, value):
+ def __init__(self, value, is_opaque=False):
+ self.is_opaque = is_opaque
self.known_class = value.known_class
self.level = value.level
if value.intbound is None:
@@ -357,6 +358,9 @@
if self.lenbound or other.lenbound:
raise InvalidLoop('The array length bounds does not match.')
+ if self.is_opaque:
+ raise InvalidLoop('Generating guards for opaque pointers is not safe')
+
if self.level == LEVEL_KNOWNCLASS and \
box.nonnull() and \
self.known_class.same_constant(cpu.ts.cls_of_box(box)):
@@ -560,7 +564,8 @@
return VirtualState([self.state(box) for box in jump_args])
def make_not_virtual(self, value):
- return NotVirtualStateInfo(value)
+ is_opaque = value in self.optimizer.opaque_pointers
+ return NotVirtualStateInfo(value, is_opaque)
def make_virtual(self, known_class, fielddescrs):
return VirtualStateInfo(known_class, fielddescrs)
@@ -585,6 +590,7 @@
self.rename = {}
self.optimizer = optimizer
self.availible_boxes = availible_boxes
+ self.assumed_classes = {}
if surviving_boxes is not None:
for box in surviving_boxes:
@@ -678,6 +684,12 @@
raise BoxNotProducable
def add_potential(self, op, synthetic=False):
+ if op.result and op.result in self.optimizer.values:
+ value = self.optimizer.values[op.result]
+ if value in self.optimizer.opaque_pointers:
+ classbox = value.get_constant_class(self.optimizer.cpu)
+ if classbox:
+ self.assumed_classes[op.result] = classbox
if op.result not in self.potential_ops:
self.potential_ops[op.result] = op
else:
diff --git a/pypy/jit/metainterp/pyjitpl.py b/pypy/jit/metainterp/pyjitpl.py
--- a/pypy/jit/metainterp/pyjitpl.py
+++ b/pypy/jit/metainterp/pyjitpl.py
@@ -222,7 +222,7 @@
'float_neg', 'float_abs',
'cast_ptr_to_int', 'cast_int_to_ptr',
'convert_float_bytes_to_longlong',
- 'convert_longlong_bytes_to_float',
+ 'convert_longlong_bytes_to_float', 'int_force_ge_zero',
]:
exec py.code.Source('''
@arguments("box")
diff --git a/pypy/jit/metainterp/resoperation.py b/pypy/jit/metainterp/resoperation.py
--- a/pypy/jit/metainterp/resoperation.py
+++ b/pypy/jit/metainterp/resoperation.py
@@ -443,6 +443,7 @@
'INT_IS_TRUE/1b',
'INT_NEG/1',
'INT_INVERT/1',
+ 'INT_FORCE_GE_ZERO/1',
#
'SAME_AS/1', # gets a Const or a Box, turns it into another Box
'CAST_PTR_TO_INT/1',
diff --git a/pypy/jit/metainterp/resume.py b/pypy/jit/metainterp/resume.py
--- a/pypy/jit/metainterp/resume.py
+++ b/pypy/jit/metainterp/resume.py
@@ -10,6 +10,7 @@
from pypy.rpython import annlowlevel
from pypy.rlib import rarithmetic, rstack
from pypy.rlib.objectmodel import we_are_translated, specialize
+from pypy.rlib.objectmodel import compute_unique_id
from pypy.rlib.debug import have_debug_prints, ll_assert
from pypy.rlib.debug import debug_start, debug_stop, debug_print
from pypy.jit.metainterp.optimize import InvalidLoop
@@ -493,7 +494,7 @@
return self.setfields(decoder, struct)
def debug_prints(self):
- debug_print("\tvirtualinfo", self.known_class.repr_rpython())
+ debug_print("\tvirtualinfo", self.known_class.repr_rpython(), " at ", compute_unique_id(self))
AbstractVirtualStructInfo.debug_prints(self)
@@ -509,7 +510,7 @@
return self.setfields(decoder, struct)
def debug_prints(self):
- debug_print("\tvstructinfo", self.typedescr.repr_rpython())
+ debug_print("\tvstructinfo", self.typedescr.repr_rpython(), " at ", compute_unique_id(self))
AbstractVirtualStructInfo.debug_prints(self)
class VArrayInfo(AbstractVirtualInfo):
@@ -539,7 +540,7 @@
return array
def debug_prints(self):
- debug_print("\tvarrayinfo", self.arraydescr)
+ debug_print("\tvarrayinfo", self.arraydescr, " at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -550,7 +551,7 @@
self.fielddescrs = fielddescrs
def debug_prints(self):
- debug_print("\tvarraystructinfo", self.arraydescr)
+ debug_print("\tvarraystructinfo", self.arraydescr, " at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -581,7 +582,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrplaininfo length", len(self.fieldnums))
+ debug_print("\tvstrplaininfo length", len(self.fieldnums), " at ", compute_unique_id(self))
class VStrConcatInfo(AbstractVirtualInfo):
@@ -599,7 +600,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrconcatinfo")
+ debug_print("\tvstrconcatinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -615,7 +616,7 @@
return string
def debug_prints(self):
- debug_print("\tvstrsliceinfo")
+ debug_print("\tvstrsliceinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -636,7 +637,7 @@
return string
def debug_prints(self):
- debug_print("\tvuniplaininfo length", len(self.fieldnums))
+ debug_print("\tvuniplaininfo length", len(self.fieldnums), " at ", compute_unique_id(self))
class VUniConcatInfo(AbstractVirtualInfo):
@@ -654,7 +655,7 @@
return string
def debug_prints(self):
- debug_print("\tvuniconcatinfo")
+ debug_print("\tvuniconcatinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -671,7 +672,7 @@
return string
def debug_prints(self):
- debug_print("\tvunisliceinfo")
+ debug_print("\tvunisliceinfo at ", compute_unique_id(self))
for i in self.fieldnums:
debug_print("\t\t", str(untag(i)))
@@ -1280,7 +1281,6 @@
def dump_storage(storage, liveboxes):
"For profiling only."
- from pypy.rlib.objectmodel import compute_unique_id
debug_start("jit-resume")
if have_debug_prints():
debug_print('Log storage', compute_unique_id(storage))
@@ -1313,4 +1313,13 @@
debug_print('\t\t', 'None')
else:
virtual.debug_prints()
+ if storage.rd_pendingfields:
+ debug_print('\tpending setfields')
+ for i in range(len(storage.rd_pendingfields)):
+ lldescr = storage.rd_pendingfields[i].lldescr
+ num = storage.rd_pendingfields[i].num
+ fieldnum = storage.rd_pendingfields[i].fieldnum
+ itemindex= storage.rd_pendingfields[i].itemindex
+ debug_print("\t\t", str(lldescr), str(untag(num)), str(untag(fieldnum)), itemindex)
+
debug_stop("jit-resume")
diff --git a/pypy/jit/metainterp/test/test_dict.py b/pypy/jit/metainterp/test/test_dict.py
--- a/pypy/jit/metainterp/test/test_dict.py
+++ b/pypy/jit/metainterp/test/test_dict.py
@@ -161,6 +161,22 @@
'guard_no_exception': 8, 'new': 2,
'guard_false': 2, 'int_is_true': 2})
+ def test_unrolling_of_dict_iter(self):
+ driver = JitDriver(greens = [], reds = ['n'])
+
+ def f(n):
+ while n > 0:
+ driver.jit_merge_point(n=n)
+ d = {1: 1}
+ for elem in d:
+ n -= elem
+ return n
+
+ res = self.meta_interp(f, [10], listops=True)
+ assert res == 0
+ self.check_simple_loop({'int_sub': 1, 'int_gt': 1, 'guard_true': 1,
+ 'jump': 1})
+
class TestOOtype(DictTests, OOJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_list.py b/pypy/jit/metainterp/test/test_list.py
--- a/pypy/jit/metainterp/test/test_list.py
+++ b/pypy/jit/metainterp/test/test_list.py
@@ -251,6 +251,16 @@
self.meta_interp(f, [10], listops=True)
self.check_resops(new_array=0, call=0)
+ def test_list_mul(self):
+ def f(i):
+ l = [0] * i
+ return len(l)
+
+ r = self.interp_operations(f, [3])
+ assert r == 3
+ r = self.interp_operations(f, [-1])
+ assert r == 0
+
class TestOOtype(ListTests, OOJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_loop.py b/pypy/jit/metainterp/test/test_loop.py
--- a/pypy/jit/metainterp/test/test_loop.py
+++ b/pypy/jit/metainterp/test/test_loop.py
@@ -871,6 +871,42 @@
res = self.meta_interp(f, [20, 10, 1])
assert res == f(20, 10, 1)
+ def test_boxed_unerased_pointers_in_short_preamble(self):
+ from pypy.rlib.rerased import new_erasing_pair
+ from pypy.rpython.lltypesystem import lltype
+ class A(object):
+ def __init__(self, val):
+ self.val = val
+ def tst(self):
+ return self.val
+
+ class Box(object):
+ def __init__(self, val):
+ self.val = val
+
+ erase_A, unerase_A = new_erasing_pair('A')
+ erase_TP, unerase_TP = new_erasing_pair('TP')
+ TP = lltype.GcArray(lltype.Signed)
+ myjitdriver = JitDriver(greens = [], reds = ['n', 'm', 'i', 'sa', 'p'])
+ def f(n, m):
+ i = sa = 0
+ p = Box(erase_A(A(7)))
+ while i < n:
+ myjitdriver.jit_merge_point(n=n, m=m, i=i, sa=sa, p=p)
+ if i < m:
+ sa += unerase_A(p.val).tst()
+ elif i == m:
+ a = lltype.malloc(TP, 5)
+ a[0] = 42
+ p = Box(erase_TP(a))
+ else:
+ sa += unerase_TP(p.val)[0]
+ sa -= A(i).val
+ i += 1
+ return sa
+ res = self.meta_interp(f, [20, 10])
+ assert res == f(20, 10)
+
class TestOOtype(LoopTest, OOJitMixin):
pass
diff --git a/pypy/jit/metainterp/test/test_virtualstate.py b/pypy/jit/metainterp/test/test_virtualstate.py
--- a/pypy/jit/metainterp/test/test_virtualstate.py
+++ b/pypy/jit/metainterp/test/test_virtualstate.py
@@ -908,6 +908,141 @@
"""
self.optimize_bridge(loop, bridge, expected, p5=self.myptr, p6=self.myptr2)
+ def test_licm_boxed_opaque_getitem(self):
+ loop = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p2)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p1)
+ """
+ bridge = """
+ [p1]
+ guard_nonnull(p1) []
+ jump(p1)
+ """
+ expected = """
+ [p1]
+ guard_nonnull(p1) []
+ p2 = getfield_gc(p1, descr=nextdescr)
+ jump(p1)
+ """
+ self.optimize_bridge(loop, bridge, expected, 'Preamble')
+
+ bridge = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ guard_class(p2, ConstClass(node_vtable2)) []
+ jump(p1)
+ """
+ expected = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ guard_class(p2, ConstClass(node_vtable2)) []
+ jump(p1)
+ """
+ self.optimize_bridge(loop, bridge, expected, 'Preamble')
+
+ bridge = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ guard_class(p2, ConstClass(node_vtable)) []
+ jump(p1)
+ """
+ expected = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ jump(p1, i3)
+ """
+ self.optimize_bridge(loop, bridge, expected, 'Loop')
+
+ def test_licm_unboxed_opaque_getitem(self):
+ loop = """
+ [p2]
+ mark_opaque_ptr(p2)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ jump(p2)
+ """
+ bridge = """
+ [p1]
+ guard_nonnull(p1) []
+ jump(p1)
+ """
+ self.optimize_bridge(loop, bridge, 'RETRACE', p1=self.myptr)
+ self.optimize_bridge(loop, bridge, 'RETRACE', p1=self.myptr2)
+
+ bridge = """
+ [p2]
+ guard_class(p2, ConstClass(node_vtable2)) []
+ jump(p2)
+ """
+ self.optimize_bridge(loop, bridge, 'RETRACE')
+
+ bridge = """
+ [p2]
+ guard_class(p2, ConstClass(node_vtable)) []
+ jump(p2)
+ """
+ expected = """
+ [p2]
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ jump(p2, i3)
+ """
+ self.optimize_bridge(loop, bridge, expected, 'Loop')
+
+ def test_licm_virtual_opaque_getitem(self):
+ loop = """
+ [p1]
+ p2 = getfield_gc(p1, descr=nextdescr)
+ mark_opaque_ptr(p2)
+ guard_class(p2, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p2, descr=otherdescr)
+ i4 = call(i3, descr=nonwritedescr)
+ p3 = new_with_vtable(ConstClass(node_vtable))
+ setfield_gc(p3, p2, descr=nextdescr)
+ jump(p3)
+ """
+ bridge = """
+ [p1]
+ p3 = new_with_vtable(ConstClass(node_vtable))
+ setfield_gc(p3, p1, descr=nextdescr)
+ jump(p3)
+ """
+ self.optimize_bridge(loop, bridge, 'RETRACE', p1=self.myptr)
+ self.optimize_bridge(loop, bridge, 'RETRACE', p1=self.myptr2)
+
+ bridge = """
+ [p1]
+ p3 = new_with_vtable(ConstClass(node_vtable))
+ guard_class(p1, ConstClass(node_vtable2)) []
+ setfield_gc(p3, p1, descr=nextdescr)
+ jump(p3)
+ """
+ self.optimize_bridge(loop, bridge, 'RETRACE')
+
+ bridge = """
+ [p1]
+ p3 = new_with_vtable(ConstClass(node_vtable))
+ guard_class(p1, ConstClass(node_vtable)) []
+ setfield_gc(p3, p1, descr=nextdescr)
+ jump(p3)
+ """
+ expected = """
+ [p1]
+ guard_class(p1, ConstClass(node_vtable)) []
+ i3 = getfield_gc(p1, descr=otherdescr)
+ jump(p1, i3)
+ """
+ self.optimize_bridge(loop, bridge, expected)
+
+
class TestLLtypeGuards(BaseTestGenerateGuards, LLtypeMixin):
pass
@@ -915,6 +1050,9 @@
pass
class FakeOptimizer:
+ def __init__(self):
+ self.opaque_pointers = {}
+ self.values = {}
def make_equal_to(*args):
pass
def getvalue(*args):
diff --git a/pypy/jit/tl/pypyjit_demo.py b/pypy/jit/tl/pypyjit_demo.py
--- a/pypy/jit/tl/pypyjit_demo.py
+++ b/pypy/jit/tl/pypyjit_demo.py
@@ -1,19 +1,27 @@
import pypyjit
pypyjit.set_param(threshold=200)
+kwargs = {"z": 1}
-def g(*args):
- return len(args)
+def f(*args, **kwargs):
+ result = g(1, *args, **kwargs)
+ return result + 2
-def f(n):
- s = 0
- for i in range(n):
- l = [i, n, 2]
- s += g(*l)
- return s
+def g(x, y, z=2):
+ return x - y + z
+
+def main():
+ res = 0
+ i = 0
+ while i < 10000:
+ res = f(res, z=i)
+ g(1, res, **kwargs)
+ i += 1
+ return res
+
try:
- print f(301)
+ print main()
except Exception, e:
print "Exception: ", type(e)
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
@@ -43,6 +43,8 @@
'do_what_I_mean' : 'interp_magic.do_what_I_mean',
'list_strategy' : 'interp_magic.list_strategy',
'validate_fd' : 'interp_magic.validate_fd',
+ 'newdict' : 'interp_dict.newdict',
+ 'dictstrategy' : 'interp_dict.dictstrategy',
}
if sys.platform == 'win32':
interpleveldefs['get_console_cp'] = 'interp_magic.get_console_cp'
diff --git a/pypy/module/__pypy__/interp_dict.py b/pypy/module/__pypy__/interp_dict.py
new file mode 100644
--- /dev/null
+++ b/pypy/module/__pypy__/interp_dict.py
@@ -0,0 +1,24 @@
+
+from pypy.interpreter.gateway import unwrap_spec
+from pypy.interpreter.error import operationerrfmt, OperationError
+from pypy.objspace.std.dictmultiobject import W_DictMultiObject
+
+ at unwrap_spec(type=str)
+def newdict(space, type):
+ if type == 'module':
+ return space.newdict(module=True)
+ elif type == 'instance':
+ return space.newdict(instance=True)
+ elif type == 'kwargs':
+ return space.newdict(kwargs=True)
+ elif type == 'strdict':
+ return space.newdict(strdict=True)
+ else:
+ raise operationerrfmt(space.w_TypeError, "unknown type of dict %s",
+ type)
+
+def dictstrategy(space, w_obj):
+ if not isinstance(w_obj, W_DictMultiObject):
+ raise OperationError(space.w_TypeError,
+ space.wrap("expecting dict object"))
+ return space.wrap('%r' % (w_obj.strategy,))
diff --git a/pypy/module/_sre/interp_sre.py b/pypy/module/_sre/interp_sre.py
--- a/pypy/module/_sre/interp_sre.py
+++ b/pypy/module/_sre/interp_sre.py
@@ -7,7 +7,7 @@
from pypy.interpreter.error import OperationError
from pypy.rlib.rarithmetic import intmask
from pypy.tool.pairtype import extendabletype
-
+from pypy.rlib import jit
# ____________________________________________________________
#
@@ -344,6 +344,7 @@
raise OperationError(space.w_TypeError,
space.wrap("cannot copy this match object"))
+ @jit.look_inside_iff(lambda self, args_w: jit.isconstant(len(args_w)))
def group_w(self, args_w):
space = self.space
ctx = self.ctx
diff --git a/pypy/module/cpyext/__init__.py b/pypy/module/cpyext/__init__.py
--- a/pypy/module/cpyext/__init__.py
+++ b/pypy/module/cpyext/__init__.py
@@ -28,7 +28,6 @@
# import these modules to register api functions by side-effect
-import pypy.module.cpyext.thread
import pypy.module.cpyext.pyobject
import pypy.module.cpyext.boolobject
import pypy.module.cpyext.floatobject
diff --git a/pypy/module/cpyext/api.py b/pypy/module/cpyext/api.py
--- a/pypy/module/cpyext/api.py
+++ b/pypy/module/cpyext/api.py
@@ -48,8 +48,10 @@
pypydir = py.path.local(autopath.pypydir)
include_dir = pypydir / 'module' / 'cpyext' / 'include'
source_dir = pypydir / 'module' / 'cpyext' / 'src'
+translator_c_dir = pypydir / 'translator' / 'c'
include_dirs = [
include_dir,
+ translator_c_dir,
udir,
]
@@ -372,6 +374,8 @@
'PyObject_AsReadBuffer', 'PyObject_AsWriteBuffer', 'PyObject_CheckReadBuffer',
'PyOS_getsig', 'PyOS_setsig',
+ 'PyThread_get_thread_ident', 'PyThread_allocate_lock', 'PyThread_free_lock',
+ 'PyThread_acquire_lock', 'PyThread_release_lock',
'PyThread_create_key', 'PyThread_delete_key', 'PyThread_set_key_value',
'PyThread_get_key_value', 'PyThread_delete_key_value',
'PyThread_ReInitTLS',
@@ -715,7 +719,8 @@
global_objects.append('%s %s = NULL;' % (typ, name))
global_code = '\n'.join(global_objects)
- prologue = "#include <Python.h>\n"
+ prologue = ("#include <Python.h>\n"
+ "#include <src/thread.h>\n")
code = (prologue +
struct_declaration_code +
global_code +
diff --git a/pypy/module/cpyext/include/pythread.h b/pypy/module/cpyext/include/pythread.h
--- a/pypy/module/cpyext/include/pythread.h
+++ b/pypy/module/cpyext/include/pythread.h
@@ -1,28 +1,35 @@
-#ifndef Py_PYTHREAD_H
-#define Py_PYTHREAD_H
-
-#define WITH_THREAD
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef void *PyThread_type_lock;
-#define WAIT_LOCK 1
-#define NOWAIT_LOCK 0
-
-/* Thread Local Storage (TLS) API */
-PyAPI_FUNC(int) PyThread_create_key(void);
-PyAPI_FUNC(void) PyThread_delete_key(int);
-PyAPI_FUNC(int) PyThread_set_key_value(int, void *);
-PyAPI_FUNC(void *) PyThread_get_key_value(int);
-PyAPI_FUNC(void) PyThread_delete_key_value(int key);
-
-/* Cleanup after a fork */
-PyAPI_FUNC(void) PyThread_ReInitTLS(void);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
+#ifndef Py_PYTHREAD_H
+#define Py_PYTHREAD_H
+
+#define WITH_THREAD
+
+typedef void *PyThread_type_lock;
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+PyAPI_FUNC(long) PyThread_get_thread_ident(void);
+
+PyAPI_FUNC(PyThread_type_lock) PyThread_allocate_lock(void);
+PyAPI_FUNC(void) PyThread_free_lock(PyThread_type_lock);
+PyAPI_FUNC(int) PyThread_acquire_lock(PyThread_type_lock, int);
+#define WAIT_LOCK 1
+#define NOWAIT_LOCK 0
+PyAPI_FUNC(void) PyThread_release_lock(PyThread_type_lock);
+
+/* Thread Local Storage (TLS) API */
+PyAPI_FUNC(int) PyThread_create_key(void);
+PyAPI_FUNC(void) PyThread_delete_key(int);
+PyAPI_FUNC(int) PyThread_set_key_value(int, void *);
+PyAPI_FUNC(void *) PyThread_get_key_value(int);
+PyAPI_FUNC(void) PyThread_delete_key_value(int key);
+
+/* Cleanup after a fork */
+PyAPI_FUNC(void) PyThread_ReInitTLS(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/pypy/module/cpyext/src/thread.c b/pypy/module/cpyext/src/thread.c
--- a/pypy/module/cpyext/src/thread.c
+++ b/pypy/module/cpyext/src/thread.c
@@ -1,6 +1,55 @@
#include <Python.h>
#include "pythread.h"
+/* With PYPY_NOT_MAIN_FILE only declarations are imported */
+#define PYPY_NOT_MAIN_FILE
+#include "src/thread.h"
+
+long
+PyThread_get_thread_ident(void)
+{
+ return RPyThreadGetIdent();
+}
+
+PyThread_type_lock
+PyThread_allocate_lock(void)
+{
+ struct RPyOpaque_ThreadLock *lock;
+ lock = malloc(sizeof(struct RPyOpaque_ThreadLock));
+ if (lock == NULL)
+ return NULL;
+
+ if (RPyThreadLockInit(lock) == 0) {
+ free(lock);
+ return NULL;
+ }
+
+ return (PyThread_type_lock)lock;
+}
+
+void
+PyThread_free_lock(PyThread_type_lock lock)
+{
+ struct RPyOpaque_ThreadLock *real_lock = lock;
+ RPyThreadAcquireLock(real_lock, 0);
+ RPyThreadReleaseLock(real_lock);
+ RPyOpaqueDealloc_ThreadLock(real_lock);
+ free(lock);
+}
+
+int
+PyThread_acquire_lock(PyThread_type_lock lock, int waitflag)
+{
+ return RPyThreadAcquireLock((struct RPyOpaqueThreadLock*)lock, waitflag);
+}
+
+void
+PyThread_release_lock(PyThread_type_lock lock)
+{
+ RPyThreadReleaseLock((struct RPyOpaqueThreadLock*)lock);
+}
+
+
/* ------------------------------------------------------------------------
Per-thread data ("key") support.
diff --git a/pypy/module/cpyext/test/test_thread.py b/pypy/module/cpyext/test/test_thread.py
--- a/pypy/module/cpyext/test/test_thread.py
+++ b/pypy/module/cpyext/test/test_thread.py
@@ -1,18 +1,21 @@
import py
-import thread
-import threading
-
-from pypy.module.thread.ll_thread import allocate_ll_lock
-from pypy.module.cpyext.test.test_api import BaseApiTest
from pypy.module.cpyext.test.test_cpyext import AppTestCpythonExtensionBase
-class TestPyThread(BaseApiTest):
- def test_get_thread_ident(self, space, api):
+class AppTestThread(AppTestCpythonExtensionBase):
+ def test_get_thread_ident(self):
+ module = self.import_extension('foo', [
+ ("get_thread_ident", "METH_NOARGS",
+ """
+ /* Use the 'PyPy' prefix to ensure we access our functions */
+ return PyInt_FromLong(PyPyThread_get_thread_ident());
+ """),
+ ])
+ import thread, threading
results = []
def some_thread():
- res = api.PyThread_get_thread_ident()
+ res = module.get_thread_ident()
results.append((res, thread.get_ident()))
some_thread()
@@ -25,23 +28,46 @@
assert results[0][0] != results[1][0]
- def test_acquire_lock(self, space, api):
- assert hasattr(api, 'PyThread_acquire_lock')
- lock = api.PyThread_allocate_lock()
- assert api.PyThread_acquire_lock(lock, 1) == 1
- assert api.PyThread_acquire_lock(lock, 0) == 0
- api.PyThread_free_lock(lock)
+ def test_acquire_lock(self):
+ module = self.import_extension('foo', [
+ ("test_acquire_lock", "METH_NOARGS",
+ """
+ /* Use the 'PyPy' prefix to ensure we access our functions */
+ PyThread_type_lock lock = PyPyThread_allocate_lock();
+ if (PyPyThread_acquire_lock(lock, 1) != 1) {
+ PyErr_SetString(PyExc_AssertionError, "first acquire");
+ return NULL;
+ }
+ if (PyPyThread_acquire_lock(lock, 0) != 0) {
+ PyErr_SetString(PyExc_AssertionError, "second acquire");
+ return NULL;
+ }
+ PyPyThread_free_lock(lock);
- def test_release_lock(self, space, api):
- assert hasattr(api, 'PyThread_acquire_lock')
- lock = api.PyThread_allocate_lock()
- api.PyThread_acquire_lock(lock, 1)
- api.PyThread_release_lock(lock)
- assert api.PyThread_acquire_lock(lock, 0) == 1
- api.PyThread_free_lock(lock)
+ Py_RETURN_NONE;
+ """),
+ ])
+ module.test_acquire_lock()
+ def test_release_lock(self):
+ module = self.import_extension('foo', [
+ ("test_release_lock", "METH_NOARGS",
+ """
+ /* Use the 'PyPy' prefix to ensure we access our functions */
+ PyThread_type_lock lock = PyPyThread_allocate_lock();
+ PyPyThread_acquire_lock(lock, 1);
+ PyPyThread_release_lock(lock);
+ if (PyPyThread_acquire_lock(lock, 0) != 1) {
+ PyErr_SetString(PyExc_AssertionError, "first acquire");
+ return NULL;
+ }
+ PyPyThread_free_lock(lock);
-class AppTestThread(AppTestCpythonExtensionBase):
+ Py_RETURN_NONE;
+ """),
+ ])
+ module.test_release_lock()
+
def test_tls(self):
module = self.import_extension('foo', [
("create_key", "METH_NOARGS",
diff --git a/pypy/module/cpyext/thread.py b/pypy/module/cpyext/thread.py
deleted file mode 100644
--- a/pypy/module/cpyext/thread.py
+++ /dev/null
@@ -1,32 +0,0 @@
-
-from pypy.module.thread import ll_thread
-from pypy.module.cpyext.api import CANNOT_FAIL, cpython_api
-from pypy.rpython.lltypesystem import lltype, rffi
-
- at cpython_api([], rffi.LONG, error=CANNOT_FAIL)
-def PyThread_get_thread_ident(space):
- return ll_thread.get_ident()
-
-LOCKP = rffi.COpaquePtr(typedef='PyThread_type_lock')
-
- at cpython_api([], LOCKP)
-def PyThread_allocate_lock(space):
- lock = ll_thread.allocate_ll_lock()
- return rffi.cast(LOCKP, lock)
-
- at cpython_api([LOCKP], lltype.Void)
-def PyThread_free_lock(space, lock):
- lock = rffi.cast(ll_thread.TLOCKP, lock)
- ll_thread.free_ll_lock(lock)
-
- at cpython_api([LOCKP, rffi.INT], rffi.INT, error=CANNOT_FAIL)
-def PyThread_acquire_lock(space, lock, waitflag):
- lock = rffi.cast(ll_thread.TLOCKP, lock)
- return ll_thread.c_thread_acquirelock(lock, waitflag)
-
- at cpython_api([LOCKP], lltype.Void)
-def PyThread_release_lock(space, lock):
- lock = rffi.cast(ll_thread.TLOCKP, lock)
- ll_thread.c_thread_releaselock(lock)
-
-
diff --git a/pypy/module/pypyjit/test_pypy_c/model.py b/pypy/module/pypyjit/test_pypy_c/model.py
--- a/pypy/module/pypyjit/test_pypy_c/model.py
+++ b/pypy/module/pypyjit/test_pypy_c/model.py
@@ -286,7 +286,7 @@
line = line.strip()
if not line:
return None
- if line == '...':
+ if line in ('...', '{{{', '}}}'):
return line
opname, _, args = line.partition('(')
opname = opname.strip()
@@ -346,10 +346,21 @@
def is_const(cls, v1):
return isinstance(v1, str) and v1.startswith('ConstClass(')
+ @staticmethod
+ def as_numeric_const(v1):
+ try:
+ return int(v1)
+ except (ValueError, TypeError):
+ return None
+
def match_var(self, v1, exp_v2):
assert v1 != '_'
if exp_v2 == '_':
return True
+ n1 = self.as_numeric_const(v1)
+ n2 = self.as_numeric_const(exp_v2)
+ if n1 is not None and n2 is not None:
+ return n1 == n2
if self.is_const(v1) or self.is_const(exp_v2):
return v1[:-1].startswith(exp_v2[:-1])
if v1 not in self.alpha_map:
@@ -385,27 +396,54 @@
self._assert(not assert_raises, "operation list too long")
return op
+ def try_match(self, op, exp_op):
+ try:
+ # try to match the op, but be sure not to modify the
+ # alpha-renaming map in case the match does not work
+ alpha_map = self.alpha_map.copy()
+ self.match_op(op, exp_op)
+ except InvalidMatch:
+ # it did not match: rollback the alpha_map
+ self.alpha_map = alpha_map
+ return False
+ else:
+ return True
+
def match_until(self, until_op, iter_ops):
while True:
op = self._next_op(iter_ops)
- try:
- # try to match the op, but be sure not to modify the
- # alpha-renaming map in case the match does not work
- alpha_map = self.alpha_map.copy()
- self.match_op(op, until_op)
- except InvalidMatch:
- # it did not match: rollback the alpha_map, and just skip this
- # operation
- self.alpha_map = alpha_map
- else:
+ if self.try_match(op, until_op):
# it matched! The '...' operator ends here
return op
+ def match_any_order(self, iter_exp_ops, iter_ops, ignore_ops):
+ exp_ops = []
+ for exp_op in iter_exp_ops:
+ if exp_op == '}}}':
+ break
+ exp_ops.append(exp_op)
+ else:
+ assert 0, "'{{{' not followed by '}}}'"
+ while exp_ops:
+ op = self._next_op(iter_ops)
+ if op.name in ignore_ops:
+ continue
+ # match 'op' against any of the exp_ops; the first successful
+ # match is kept, and the exp_op gets removed from the list
+ for i, exp_op in enumerate(exp_ops):
+ if self.try_match(op, exp_op):
+ del exp_ops[i]
+ break
+ else:
+ self._assert(0, \
+ "operation %r not found within the {{{ }}} block" % (op,))
+
def match_loop(self, expected_ops, ignore_ops):
"""
A note about partial matching: the '...' operator is non-greedy,
i.e. it matches all the operations until it finds one that matches
- what is after the '...'
+ what is after the '...'. The '{{{' and '}}}' operators mark a
+ group of lines that can match in any order.
"""
iter_exp_ops = iter(expected_ops)
iter_ops = RevertableIterator(self.ops)
@@ -420,6 +458,9 @@
# return because it matches everything until the end
return
op = self.match_until(exp_op, iter_ops)
+ elif exp_op == '{{{':
+ self.match_any_order(iter_exp_ops, iter_ops, ignore_ops)
+ continue
else:
while True:
op = self._next_op(iter_ops)
@@ -427,7 +468,7 @@
break
self.match_op(op, exp_op)
except InvalidMatch, e:
- if exp_op[4] is False: # optional operation
+ if type(exp_op) is not str and exp_op[4] is False: # optional operation
iter_ops.revert_one()
continue # try to match with the next exp_op
e.opindex = iter_ops.index - 1
diff --git a/pypy/module/pypyjit/test_pypy_c/test_00_model.py b/pypy/module/pypyjit/test_pypy_c/test_00_model.py
--- a/pypy/module/pypyjit/test_pypy_c/test_00_model.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_00_model.py
@@ -200,6 +200,12 @@
# missing op at the end
"""
assert not self.match(loop, expected)
+ #
+ expected = """
+ i5 = int_add(i2, 2)
+ jump(i5, descr=...)
+ """
+ assert not self.match(loop, expected)
def test_match_descr(self):
loop = """
@@ -291,6 +297,49 @@
"""
assert self.match(loop, expected)
+ def test_match_any_order(self):
+ loop = """
+ [i0, i1]
+ i2 = int_add(i0, 1)
+ i3 = int_add(i1, 2)
+ jump(i2, i3, descr=...)
+ """
+ expected = """
+ {{{
+ i2 = int_add(i0, 1)
+ i3 = int_add(i1, 2)
+ }}}
+ jump(i2, i3, descr=...)
+ """
+ assert self.match(loop, expected)
+ #
+ expected = """
+ {{{
+ i3 = int_add(i1, 2)
+ i2 = int_add(i0, 1)
+ }}}
+ jump(i2, i3, descr=...)
+ """
+ assert self.match(loop, expected)
+ #
+ expected = """
+ {{{
+ i2 = int_add(i0, 1)
+ i3 = int_add(i1, 2)
+ i4 = int_add(i1, 3)
+ }}}
+ jump(i2, i3, descr=...)
+ """
+ assert not self.match(loop, expected)
+ #
+ expected = """
+ {{{
+ i2 = int_add(i0, 1)
+ }}}
+ jump(i2, i3, descr=...)
+ """
+ assert not self.match(loop, expected)
+
class TestRunPyPyC(BaseTestPyPyC):
@@ -444,7 +493,7 @@
i8 = int_add(i4, 1)
# signal checking stuff
guard_not_invalidated(descr=...)
- i10 = getfield_raw(37212896, descr=<.* pypysig_long_struct.c_value .*>)
+ i10 = getfield_raw(..., descr=<.* pypysig_long_struct.c_value .*>)
i14 = int_lt(i10, 0)
guard_false(i14, descr=...)
jump(p0, p1, p2, p3, i8, descr=...)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_call.py b/pypy/module/pypyjit/test_pypy_c/test_call.py
--- a/pypy/module/pypyjit/test_pypy_c/test_call.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_call.py
@@ -1,5 +1,6 @@
import py
from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
+from pypy.module.pypyjit.test_pypy_c.model import OpMatcher
class TestCall(BaseTestPyPyC):
@@ -369,14 +370,17 @@
# make sure that the "block" is not allocated
...
i20 = force_token()
- p22 = new_with_vtable(19511408)
+ p22 = new_with_vtable(...)
p24 = new_array(1, descr=<ArrayP .>)
p26 = new_with_vtable(ConstClass(W_ListObject))
+ {{{
setfield_gc(p0, i20, descr=<FieldS .*PyFrame.vable_token .*>)
+ setfield_gc(p22, 1, descr=<FieldU pypy.interpreter.argument.Arguments.inst__jit_few_keywords .*>)
setfield_gc(p26, ConstPtr(ptr22), descr=<FieldP pypy.objspace.std.listobject.W_ListObject.inst_strategy .*>)
setarrayitem_gc(p24, 0, p26, descr=<ArrayP .>)
setfield_gc(p22, p24, descr=<FieldP .*Arguments.inst_arguments_w .*>)
- p32 = call_may_force(11376960, p18, p22, descr=<Callr . rr EF=6>)
+ }}}
+ p32 = call_may_force(..., p18, p22, descr=<Callr . rr EF=6>)
...
""")
@@ -506,7 +510,6 @@
return res""", [1000])
assert log.result == 500
loop, = log.loops_by_id('call')
- print loop.ops_by_id('call')
assert loop.match("""
i65 = int_lt(i58, i29)
guard_true(i65, descr=...)
@@ -522,3 +525,97 @@
jump(..., descr=...)
""")
+ def test_kwargs_virtual3(self):
+ log = self.run("""
+ def f(a, b, c):
+ pass
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ d = {'a': 2, 'b': 3, 'c': 4}
+ f(**d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ assert log.result == 13
+ loop, = log.loops_by_id('call')
+ allops = loop.allops()
+ calls = [op for op in allops if op.name.startswith('call')]
+ assert len(calls) == 0
+ assert len([op for op in allops if op.name.startswith('new')]) == 0
+
+ def test_kwargs_non_virtual(self):
+ log = self.run("""
+ def f(a, b, c):
+ pass
+
+ def main(stop):
+ d = {'a': 2, 'b': 3, 'c': 4}
+ i = 0
+ while i < stop:
+ f(**d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ assert log.result == 13
+ loop, = log.loops_by_id('call')
+ allops = loop.allops()
+ calls = [op for op in allops if op.name.startswith('call')]
+ assert OpMatcher(calls).match('''
+ p93 = call(ConstClass(view_as_kwargs), p35, p12, descr=<.*>)
+ i103 = call(ConstClass(_match_keywords), ConstPtr(ptr52), 0, 0, p94, p98, 0, descr=<.*>)
+ ''')
+ assert len([op for op in allops if op.name.startswith('new')]) == 1
+ # 1 alloc
+
+ def test_complex_case(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+ loop, = log.loops_by_id('call')
+ assert loop.match_by_id('call', '''
+ guard_not_invalidated(descr=<.*>)
+ i1 = force_token()
+ ''')
+
+ def test_complex_case_global(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+
+ def main(stop):
+ i = 0
+ while i < stop:
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
+
+ def test_complex_case_loopconst(self):
+ log = self.run("""
+ def f(x, y, a, b, c=3, d=4):
+ pass
+
+ def main(stop):
+ i = 0
+ a = [1, 2]
+ d = {'a': 2, 'b': 3, 'd':4}
+ while i < stop:
+ f(*a, **d) # ID: call
+ i += 1
+ return 13
+ """, [1000])
diff --git a/pypy/module/pypyjit/test_pypy_c/test_misc.py b/pypy/module/pypyjit/test_pypy_c/test_misc.py
--- a/pypy/module/pypyjit/test_pypy_c/test_misc.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_misc.py
@@ -241,7 +241,7 @@
p17 = getarrayitem_gc(p16, i12, descr=<ArrayP .>)
i19 = int_add(i12, 1)
setfield_gc(p9, i19, descr=<FieldS .*W_AbstractSeqIterObject.inst_index .*>)
- guard_nonnull_class(p17, 146982464, descr=...)
+ guard_nonnull_class(p17, ..., descr=...)
i21 = getfield_gc(p17, descr=<FieldS .*W_Array.*.inst_len .*>)
i23 = int_lt(0, i21)
guard_true(i23, descr=...)
diff --git a/pypy/module/pypyjit/test_pypy_c/test_shift.py b/pypy/module/pypyjit/test_pypy_c/test_shift.py
--- a/pypy/module/pypyjit/test_pypy_c/test_shift.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_shift.py
@@ -1,4 +1,4 @@
-import py
+import py, sys
from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
class TestShift(BaseTestPyPyC):
@@ -56,13 +56,17 @@
log = self.run(main, [3])
assert log.result == 99
loop, = log.loops_by_filename(self.filepath)
+ if sys.maxint == 2147483647:
+ SHIFT = 31
+ else:
+ SHIFT = 63
assert loop.match_by_id('div', """
i10 = int_floordiv(i6, i7)
i11 = int_mul(i10, i7)
i12 = int_sub(i6, i11)
- i14 = int_rshift(i12, 63)
+ i14 = int_rshift(i12, %d)
i15 = int_add(i10, i14)
- """)
+ """ % SHIFT)
def test_division_to_rshift_allcases(self):
"""
diff --git a/pypy/module/pypyjit/test_pypy_c/test_string.py b/pypy/module/pypyjit/test_pypy_c/test_string.py
--- a/pypy/module/pypyjit/test_pypy_c/test_string.py
+++ b/pypy/module/pypyjit/test_pypy_c/test_string.py
@@ -1,5 +1,10 @@
+import sys
from pypy.module.pypyjit.test_pypy_c.test_00_model import BaseTestPyPyC
+if sys.maxint == 2147483647:
+ SHIFT = 31
+else:
+ SHIFT = 63
# XXX review the <Call> descrs to replace some EF=4 with EF=3 (elidable)
@@ -22,10 +27,10 @@
i14 = int_lt(i6, i9)
guard_true(i14, descr=...)
guard_not_invalidated(descr=...)
- i16 = int_eq(i6, -9223372036854775808)
+ i16 = int_eq(i6, %d)
guard_false(i16, descr=...)
i15 = int_mod(i6, i10)
- i17 = int_rshift(i15, 63)
+ i17 = int_rshift(i15, %d)
i18 = int_and(i10, i17)
i19 = int_add(i15, i18)
i21 = int_lt(i19, 0)
@@ -45,7 +50,7 @@
i34 = int_add(i6, 1)
--TICK--
jump(p0, p1, p2, p3, p4, p5, i34, p7, p8, i9, i10, p11, i12, p13, descr=...)
- """)
+ """ % (-sys.maxint-1, SHIFT))
def test_long(self):
def main(n):
@@ -62,10 +67,10 @@
i11 = int_lt(i6, i7)
guard_true(i11, descr=...)
guard_not_invalidated(descr=...)
- i13 = int_eq(i6, -9223372036854775808)
+ i13 = int_eq(i6, %d)
guard_false(i13, descr=...)
i15 = int_mod(i6, i8)
- i17 = int_rshift(i15, 63)
+ i17 = int_rshift(i15, %d)
i18 = int_and(i8, i17)
i19 = int_add(i15, i18)
i21 = int_lt(i19, 0)
@@ -95,7 +100,7 @@
guard_false(i43, descr=...)
i46 = call(ConstClass(ll_startswith__rpy_stringPtr_rpy_stringPtr), p28, ConstPtr(ptr45), descr=<Calli 1 rr EF=0>)
guard_false(i46, descr=...)
- p51 = new_with_vtable(21136408)
+ p51 = new_with_vtable(...)
setfield_gc(p51, _, descr=...) # 7 setfields, but the order is dict-order-dependent
setfield_gc(p51, _, descr=...)
setfield_gc(p51, _, descr=...)
@@ -111,7 +116,7 @@
guard_no_overflow(descr=...)
--TICK--
jump(p0, p1, p2, p3, p4, p5, i58, i7, descr=...)
- """)
+ """ % (-sys.maxint-1, SHIFT))
def test_str_mod(self):
def main(n):
diff --git a/pypy/objspace/std/dictmultiobject.py b/pypy/objspace/std/dictmultiobject.py
--- a/pypy/objspace/std/dictmultiobject.py
+++ b/pypy/objspace/std/dictmultiobject.py
@@ -11,6 +11,7 @@
from pypy.rlib.debug import mark_dict_non_null
from pypy.rlib import rerased
+from pypy.rlib import jit
def _is_str(space, w_key):
return space.is_w(space.type(w_key), space.w_str)
@@ -28,6 +29,18 @@
space.is_w(w_lookup_type, space.w_float)
)
+
+DICT_CUTOFF = 5
+
+ at specialize.call_location()
+def w_dict_unrolling_heuristic(w_dct):
+ """ In which cases iterating over dict items can be unrolled.
+ Note that w_dct is an instance of W_DictMultiObject, not necesarilly
+ an actual dict
+ """
+ return jit.isvirtual(w_dct) or (jit.isconstant(w_dct) and
+ w_dct.length() <= DICT_CUTOFF)
+
class W_DictMultiObject(W_Object):
from pypy.objspace.std.dicttype import dict_typedef as typedef
@@ -48,8 +61,8 @@
elif kwargs:
assert w_type is None
- from pypy.objspace.std.kwargsdict import KwargsDictStrategy
- strategy = space.fromcache(KwargsDictStrategy)
+ from pypy.objspace.std.kwargsdict import EmptyKwargsDictStrategy
+ strategy = space.fromcache(EmptyKwargsDictStrategy)
else:
strategy = space.fromcache(EmptyDictStrategy)
if w_type is None:
@@ -90,13 +103,15 @@
for w_k, w_v in list_pairs_w:
w_self.setitem(w_k, w_v)
+ def view_as_kwargs(self):
+ return self.strategy.view_as_kwargs(self)
+
def _add_indirections():
dict_methods = "setitem setitem_str getitem \
getitem_str delitem length \
clear w_keys values \
items iter setdefault \
- popitem listview_str listview_int \
- view_as_kwargs".split()
+ popitem listview_str listview_int".split()
def make_method(method):
def f(self, *args):
@@ -508,6 +523,18 @@
def w_keys(self, w_dict):
return self.space.newlist_str(self.listview_str(w_dict))
+ @jit.look_inside_iff(lambda self, w_dict:
+ w_dict_unrolling_heuristic(w_dict))
+ def view_as_kwargs(self, w_dict):
+ d = self.unerase(w_dict.dstorage)
+ l = len(d)
+ keys, values = [None] * l, [None] * l
+ i = 0
+ for key, val in d.iteritems():
+ keys[i] = key
+ values[i] = val
+ i += 1
+ return keys, values
class _WrappedIteratorMixin(object):
_mixin_ = True
diff --git a/pypy/objspace/std/kwargsdict.py b/pypy/objspace/std/kwargsdict.py
--- a/pypy/objspace/std/kwargsdict.py
+++ b/pypy/objspace/std/kwargsdict.py
@@ -3,11 +3,20 @@
from pypy.rlib import rerased, jit
from pypy.objspace.std.dictmultiobject import (DictStrategy,
+ EmptyDictStrategy,
IteratorImplementation,
ObjectDictStrategy,
StringDictStrategy)
+class EmptyKwargsDictStrategy(EmptyDictStrategy):
+ def switch_to_string_strategy(self, w_dict):
+ strategy = self.space.fromcache(KwargsDictStrategy)
+ storage = strategy.get_empty_storage()
+ w_dict.strategy = strategy
+ w_dict.dstorage = storage
+
+
class KwargsDictStrategy(DictStrategy):
erase, unerase = rerased.new_erasing_pair("kwargsdict")
erase = staticmethod(erase)
@@ -145,7 +154,8 @@
w_dict.dstorage = storage
def view_as_kwargs(self, w_dict):
- return self.unerase(w_dict.dstorage)
+ keys, values_w = self.unerase(w_dict.dstorage)
+ return keys[:], values_w[:] # copy to make non-resizable
class KwargsDictIterator(IteratorImplementation):
diff --git a/pypy/objspace/std/test/test_dictmultiobject.py b/pypy/objspace/std/test/test_dictmultiobject.py
--- a/pypy/objspace/std/test/test_dictmultiobject.py
+++ b/pypy/objspace/std/test/test_dictmultiobject.py
@@ -889,6 +889,9 @@
return W_DictMultiObject.allocate_and_init_instance(
self, module=module, instance=instance)
+ def view_as_kwargs(self, w_d):
+ return w_d.view_as_kwargs() # assume it's a multidict
+
def finditem_str(self, w_dict, s):
return w_dict.getitem_str(s) # assume it's a multidict
@@ -1105,6 +1108,10 @@
assert self.impl.getitem(s) == 1000
assert s.unwrapped
+ def test_view_as_kwargs(self):
+ self.fill_impl()
+ assert self.fakespace.view_as_kwargs(self.impl) == (["fish", "fish2"], [1000, 2000])
+
## class TestMeasuringDictImplementation(BaseTestRDictImplementation):
## ImplementionClass = MeasuringDictImplementation
## DevolvedClass = MeasuringDictImplementation
diff --git a/pypy/objspace/std/test/test_kwargsdict.py b/pypy/objspace/std/test/test_kwargsdict.py
--- a/pypy/objspace/std/test/test_kwargsdict.py
+++ b/pypy/objspace/std/test/test_kwargsdict.py
@@ -86,6 +86,27 @@
d = W_DictMultiObject(space, strategy, storage)
w_l = d.w_keys() # does not crash
+def test_view_as_kwargs():
+ from pypy.objspace.std.dictmultiobject import EmptyDictStrategy
+ strategy = KwargsDictStrategy(space)
+ keys = ["a", "b", "c"]
+ values = [1, 2, 3]
+ storage = strategy.erase((keys, values))
+ d = W_DictMultiObject(space, strategy, storage)
+ assert (space.view_as_kwargs(d) == keys, values)
+
+ strategy = EmptyDictStrategy(space)
+ storage = strategy.get_empty_storage()
+ d = W_DictMultiObject(space, strategy, storage)
+ assert (space.view_as_kwargs(d) == [], [])
+
+def test_from_empty_to_kwargs():
+ strategy = EmptyKwargsDictStrategy(space)
+ storage = strategy.get_empty_storage()
+ d = W_DictMultiObject(space, strategy, storage)
+ d.setitem_str("a", 3)
+ assert isinstance(d.strategy, KwargsDictStrategy)
+
from pypy.objspace.std.test.test_dictmultiobject import BaseTestRDictImplementation, BaseTestDevolvedDictImplementation
def get_impl(self):
@@ -117,4 +138,6 @@
return args
d = f(a=1)
assert "KwargsDictStrategy" in self.get_strategy(d)
+ d = f()
+ assert "EmptyKwargsDictStrategy" in self.get_strategy(d)
diff --git a/pypy/rlib/jit.py b/pypy/rlib/jit.py
--- a/pypy/rlib/jit.py
+++ b/pypy/rlib/jit.py
@@ -103,7 +103,6 @@
import inspect
args, varargs, varkw, defaults = inspect.getargspec(func)
- args = ["v%s" % (i, ) for i in range(len(args))]
assert varargs is None and varkw is None
assert not defaults
return args
@@ -118,11 +117,11 @@
argstring = ", ".join(args)
code = ["def f(%s):\n" % (argstring, )]
if promote_args != 'all':
- args = [('v%d' % int(i)) for i in promote_args.split(",")]
+ args = [args[int(i)] for i in promote_args.split(",")]
for arg in args:
code.append(" %s = hint(%s, promote=True)\n" % (arg, arg))
- code.append(" return func(%s)\n" % (argstring, ))
- d = {"func": func, "hint": hint}
+ code.append(" return _orig_func_unlikely_name(%s)\n" % (argstring, ))
+ d = {"_orig_func_unlikely_name": func, "hint": hint}
exec py.code.Source("\n".join(code)).compile() in d
result = d["f"]
result.func_name = func.func_name + "_promote"
@@ -148,6 +147,8 @@
thing._annspecialcase_ = "specialize:call_location"
args = _get_args(func)
+ predicateargs = _get_args(predicate)
+ assert len(args) == len(predicateargs), "%s and predicate %s need the same numbers of arguments" % (func, predicate)
d = {
"dont_look_inside": dont_look_inside,
"predicate": predicate,
diff --git a/pypy/rlib/objectmodel.py b/pypy/rlib/objectmodel.py
--- a/pypy/rlib/objectmodel.py
+++ b/pypy/rlib/objectmodel.py
@@ -146,20 +146,20 @@
# we cannot simply wrap the function using *args, **kwds, because it's
# not RPython. Instead, we generate a function with exactly the same
# argument list
- argspec = inspect.getargspec(f)
- assert len(argspec.args) == len(types), (
+ srcargs, srcvarargs, srckeywords, defaults = inspect.getargspec(f)
+ assert len(srcargs) == len(types), (
'not enough types provided: expected %d, got %d' %
- (len(types), len(argspec.args)))
- assert not argspec.varargs, '*args not supported by enforceargs'
- assert not argspec.keywords, '**kwargs not supported by enforceargs'
+ (len(types), len(srcargs)))
+ assert not srcvarargs, '*args not supported by enforceargs'
+ assert not srckeywords, '**kwargs not supported by enforceargs'
#
- arglist = ', '.join(argspec.args)
+ arglist = ', '.join(srcargs)
src = py.code.Source("""
- def {name}({arglist}):
+ def %(name)s(%(arglist)s):
if not we_are_translated():
- typecheck({arglist})
- return {name}_original({arglist})
- """.format(name=f.func_name, arglist=arglist))
+ typecheck(%(arglist)s)
+ return %(name)s_original(%(arglist)s)
+ """ % dict(name=f.func_name, arglist=arglist))
#
mydict = {f.func_name + '_original': f,
'typecheck': typecheck,
diff --git a/pypy/rpython/lltypesystem/rdict.py b/pypy/rpython/lltypesystem/rdict.py
--- a/pypy/rpython/lltypesystem/rdict.py
+++ b/pypy/rpython/lltypesystem/rdict.py
@@ -713,6 +713,10 @@
def _make_ll_dictnext(kind):
# make three versions of the following function: keys, values, items
+ @jit.look_inside_iff(lambda RETURNTYPE, iter: jit.isvirtual(iter)
+ and (iter.dict is None or
+ jit.isvirtual(iter.dict)))
+ @jit.oopspec("dictiter.next%s(iter)" % kind)
def ll_dictnext(RETURNTYPE, iter):
# note that RETURNTYPE is None for keys and values
dict = iter.dict
@@ -740,7 +744,6 @@
# clear the reference to the dict and prevent restarts
iter.dict = lltype.nullptr(lltype.typeOf(iter).TO.dict.TO)
raise StopIteration
- ll_dictnext.oopspec = 'dictiter.next%s(iter)' % kind
return ll_dictnext
ll_dictnext_group = {'keys' : _make_ll_dictnext('keys'),
diff --git a/pypy/rpython/lltypesystem/rstr.py b/pypy/rpython/lltypesystem/rstr.py
--- a/pypy/rpython/lltypesystem/rstr.py
+++ b/pypy/rpython/lltypesystem/rstr.py
@@ -4,7 +4,7 @@
from pypy.rpython.error import TyperError
from pypy.rlib.objectmodel import malloc_zero_filled, we_are_translated
from pypy.rlib.objectmodel import _hash_string, enforceargs
-from pypy.rlib.objectmodel import keepalive_until_here
+from pypy.rlib.objectmodel import keepalive_until_here, specialize
from pypy.rlib.debug import ll_assert
from pypy.rlib import jit
from pypy.rlib.rarithmetic import ovfcheck
@@ -174,7 +174,7 @@
if s:
return s
else:
- return self.ll.ll_constant(u'None')
+ return self.ll.ll_constant_unicode(u'None')
@jit.elidable
def ll_encode_latin1(self, s):
@@ -963,14 +963,13 @@
def ll_build_finish(builder):
return LLHelpers.ll_join_strs(len(builder), builder)
+ @specialize.memo()
def ll_constant(s):
- if isinstance(s, str):
- return string_repr.convert_const(s)
- elif isinstance(s, unicode):
- return unicode_repr.convert_const(s)
- else:
- assert False
- ll_constant._annspecialcase_ = 'specialize:memo'
+ return string_repr.convert_const(s)
+
+ @specialize.memo()
+ def ll_constant_unicode(s):
+ return unicode_repr.convert_const(s)
def do_stringformat(cls, hop, sourcevarsrepr):
s_str = hop.args_s[0]
diff --git a/pypy/rpython/ootypesystem/rstr.py b/pypy/rpython/ootypesystem/rstr.py
--- a/pypy/rpython/ootypesystem/rstr.py
+++ b/pypy/rpython/ootypesystem/rstr.py
@@ -1,5 +1,6 @@
from pypy.tool.pairtype import pairtype
from pypy.annotation import model as annmodel
+from pypy.rlib.objectmodel import specialize
from pypy.rlib.rarithmetic import ovfcheck
from pypy.rpython.error import TyperError
from pypy.rpython.rstr import AbstractStringRepr,AbstractCharRepr,\
@@ -84,7 +85,7 @@
if s:
return s
else:
- return self.ll.ll_constant(u'None')
+ return self.ll.ll_constant_unicode(u'None')
def ll_encode_latin1(self, value):
sb = ootype.new(ootype.StringBuilder)
@@ -310,14 +311,13 @@
def ll_build_finish(buf):
return buf.ll_build()
+ @specialize.memo()
def ll_constant(s):
- if isinstance(s, str):
- return ootype.make_string(s)
- elif isinstance(s, unicode):
- return ootype.make_unicode(s)
- else:
- assert False
- ll_constant._annspecialcase_ = 'specialize:memo'
+ return ootype.make_string(s)
+
+ @specialize.memo()
+ def ll_constant_unicode(s):
+ return ootype.make_unicode(s)
def do_stringformat(cls, hop, sourcevarsrepr):
InstanceRepr = hop.rtyper.type_system.rclass.InstanceRepr
diff --git a/pypy/rpython/test/test_runicode.py b/pypy/rpython/test/test_runicode.py
--- a/pypy/rpython/test/test_runicode.py
+++ b/pypy/rpython/test/test_runicode.py
@@ -209,6 +209,18 @@
assert self.ll_to_string(res) == const(u'before None after')
#
+ def test_strformat_unicode_and_str(self):
+ # test that we correctly specialize ll_constant when we pass both a
+ # string and an unicode to it
+ const = self.const
+ def percentS(ch):
+ x = "%s" % (ch + "bc")
+ y = u"%s" % (unichr(ord(ch)) + u"bc")
+ return len(x)+len(y)
+ #
+ res = self.interpret(percentS, ["a"])
+ assert res == 6
+
def unsupported(self):
py.test.skip("not supported")
diff --git a/pypy/translator/c/funcgen.py b/pypy/translator/c/funcgen.py
--- a/pypy/translator/c/funcgen.py
+++ b/pypy/translator/c/funcgen.py
@@ -11,6 +11,7 @@
from pypy.rpython.lltypesystem.lltype import pyobjectptr, ContainerType
from pypy.rpython.lltypesystem.lltype import Struct, Array, FixedSizeArray
from pypy.rpython.lltypesystem.lltype import ForwardReference, FuncType
+from pypy.rpython.lltypesystem.rffi import INT
from pypy.rpython.lltypesystem.llmemory import Address
from pypy.translator.backendopt.ssa import SSI_to_SSA
from pypy.translator.backendopt.innerloop import find_inner_loops
@@ -750,6 +751,8 @@
continue
elif T == Signed:
format.append('%ld')
+ elif T == INT:
+ format.append('%d')
elif T == Unsigned:
format.append('%lu')
elif T == Float:
diff --git a/pypy/translator/c/test/test_standalone.py b/pypy/translator/c/test/test_standalone.py
--- a/pypy/translator/c/test/test_standalone.py
+++ b/pypy/translator/c/test/test_standalone.py
@@ -277,6 +277,8 @@
assert " ll_strtod.o" in makefile
def test_debug_print_start_stop(self):
+ from pypy.rpython.lltypesystem import rffi
+
def entry_point(argv):
x = "got:"
debug_start ("mycat")
@@ -291,6 +293,7 @@
debug_stop ("mycat")
if have_debug_prints(): x += "a"
debug_print("toplevel")
+ debug_print("some int", rffi.cast(rffi.INT, 3))
debug_flush()
os.write(1, x + "." + str(debug_offset()) + '.\n')
return 0
@@ -324,6 +327,7 @@
assert 'cat2}' in err
assert 'baz' in err
assert 'bok' in err
+ assert 'some int 3' in err
# check with PYPYLOG=:somefilename
path = udir.join('test_debug_xxx.log')
out, err = cbuilder.cmdexec("", err=True,
diff --git a/pypy/translator/cli/test/test_unicode.py b/pypy/translator/cli/test/test_unicode.py
--- a/pypy/translator/cli/test/test_unicode.py
+++ b/pypy/translator/cli/test/test_unicode.py
@@ -21,3 +21,6 @@
def test_inplace_add(self):
py.test.skip("CLI tests can't have string as input arguments")
+
+ def test_strformat_unicode_arg(self):
+ py.test.skip('fixme!')
diff --git a/pypy/translator/goal/targetbigintbenchmark.py b/pypy/translator/goal/targetbigintbenchmark.py
new file mode 100644
--- /dev/null
+++ b/pypy/translator/goal/targetbigintbenchmark.py
@@ -0,0 +1,291 @@
+#! /usr/bin/env python
+
+import os, sys
+from time import time
+from pypy.rlib.rbigint import rbigint, _k_mul, _tc_mul
+
+# __________ Entry point __________
+
+def entry_point(argv):
+ """
+ All benchmarks are run using --opt=2 and minimark gc (default).
+
+ Benchmark changes:
+ 2**N is a VERY heavy operation in default pypy, default to 10 million instead of 500,000 used like an hour to finish.
+
+ A cutout with some benchmarks.
+ Pypy default:
+ mod by 2: 7.978181
+ mod by 10000: 4.016121
+ mod by 1024 (power of two): 3.966439
+ Div huge number by 2**128: 2.906821
+ rshift: 2.444589
+ lshift: 2.500746
+ Floordiv by 2: 4.431134
+ Floordiv by 3 (not power of two): 4.404396
+ 2**500000: 23.206724
+ (2**N)**5000000 (power of two): 13.886118
+ 10000 ** BIGNUM % 100 8.464378
+ i = i * i: 10.121505
+ n**10000 (not power of two): 16.296989
+ Power of two ** power of two: 2.224125
+ v = v * power of two 12.228391
+ v = v * v 17.119933
+ v = v + v 6.489957
+ Sum: 142.686547
+
+ Pypy with improvements:
+ mod by 2: 0.006321
+ mod by 10000: 3.143117
+ mod by 1024 (power of two): 0.009611
+ Div huge number by 2**128: 2.138351
+ rshift: 2.247337
+ lshift: 1.334369
+ Floordiv by 2: 1.555604
+ Floordiv by 3 (not power of two): 4.275014
+ 2**500000: 0.033836
+ (2**N)**5000000 (power of two): 0.049600
+ 10000 ** BIGNUM % 100 1.326477
+ i = i * i: 3.924958
+ n**10000 (not power of two): 6.335759
+ Power of two ** power of two: 0.013380
+ v = v * power of two 3.497662
+ v = v * v 6.359251
+ v = v + v 2.785971
+ Sum: 39.036619
+
+ With SUPPORT_INT128 set to False
+ mod by 2: 0.004103
+ mod by 10000: 3.237434
+ mod by 1024 (power of two): 0.016363
+ Div huge number by 2**128: 2.836237
+ rshift: 2.343860
+ lshift: 1.172665
+ Floordiv by 2: 1.537474
+ Floordiv by 3 (not power of two): 3.796015
+ 2**500000: 0.327269
+ (2**N)**5000000 (power of two): 0.084709
+ 10000 ** BIGNUM % 100 2.063215
+ i = i * i: 8.109634
+ n**10000 (not power of two): 11.243292
+ Power of two ** power of two: 0.072559
+ v = v * power of two 9.753532
+ v = v * v 13.569841
+ v = v + v 5.760466
+ Sum: 65.928667
+
+ """
+ sumTime = 0.0
+
+
+ """t = time()
+ by = rbigint.fromint(2**62).lshift(1030000)
+ for n in xrange(5000):
+ by2 = by.lshift(63)
+ _tc_mul(by, by2)
+ by = by2
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Toom-cook effectivity _Tcmul 1030000-1035000 digits:", _time
+
+ t = time()
+ by = rbigint.fromint(2**62).lshift(1030000)
+ for n in xrange(5000):
+ by2 = by.lshift(63)
+ _k_mul(by, by2)
+ by = by2
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Toom-cook effectivity _kMul 1030000-1035000 digits:", _time"""
+
+
+ V2 = rbigint.fromint(2)
+ num = rbigint.pow(rbigint.fromint(100000000), rbigint.fromint(1024))
+ t = time()
+ for n in xrange(600000):
+ rbigint.mod(num, V2)
+
+ _time = time() - t
+ sumTime += _time
+ print "mod by 2: ", _time
+
+ by = rbigint.fromint(10000)
+ t = time()
+ for n in xrange(300000):
+ rbigint.mod(num, by)
+
+ _time = time() - t
+ sumTime += _time
+ print "mod by 10000: ", _time
+
+ V1024 = rbigint.fromint(1024)
+ t = time()
+ for n in xrange(300000):
+ rbigint.mod(num, V1024)
+
+ _time = time() - t
+ sumTime += _time
+ print "mod by 1024 (power of two): ", _time
+
+ t = time()
+ num = rbigint.pow(rbigint.fromint(100000000), rbigint.fromint(1024))
+ by = rbigint.pow(rbigint.fromint(2), rbigint.fromint(128))
+ for n in xrange(80000):
+ rbigint.divmod(num, by)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Div huge number by 2**128:", _time
+
+ t = time()
+ num = rbigint.fromint(1000000000)
+ for n in xrange(160000000):
+ rbigint.rshift(num, 16)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "rshift:", _time
+
+ t = time()
+ num = rbigint.fromint(1000000000)
+ for n in xrange(160000000):
+ rbigint.lshift(num, 4)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "lshift:", _time
+
+ t = time()
+ num = rbigint.fromint(100000000)
+ for n in xrange(80000000):
+ rbigint.floordiv(num, V2)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Floordiv by 2:", _time
+
+ t = time()
+ num = rbigint.fromint(100000000)
+ V3 = rbigint.fromint(3)
+ for n in xrange(80000000):
+ rbigint.floordiv(num, V3)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Floordiv by 3 (not power of two):",_time
+
+ t = time()
+ num = rbigint.fromint(500000)
+ for n in xrange(10000):
+ rbigint.pow(V2, num)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "2**500000:",_time
+
+ t = time()
+ num = rbigint.fromint(5000000)
+ for n in xrange(31):
+ rbigint.pow(rbigint.pow(V2, rbigint.fromint(n)), num)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "(2**N)**5000000 (power of two):",_time
+
+ t = time()
+ num = rbigint.pow(rbigint.fromint(10000), rbigint.fromint(2 ** 8))
+ P10_4 = rbigint.fromint(10**4)
+ V100 = rbigint.fromint(100)
+ for n in xrange(60000):
+ rbigint.pow(P10_4, num, V100)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "10000 ** BIGNUM % 100", _time
+
+ t = time()
+ i = rbigint.fromint(2**31)
+ i2 = rbigint.fromint(2**31)
+ for n in xrange(75000):
+ i = i.mul(i2)
+
+ _time = time() - t
+ sumTime += _time
+ print "i = i * i:", _time
+
+ t = time()
+
+ for n in xrange(10000):
+ rbigint.pow(rbigint.fromint(n), P10_4)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "n**10000 (not power of two):",_time
+
+ t = time()
+ for n in xrange(100000):
+ rbigint.pow(V1024, V1024)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "Power of two ** power of two:", _time
+
+
+ t = time()
+ v = rbigint.fromint(2)
+ P62 = rbigint.fromint(2**62)
+ for n in xrange(50000):
+ v = v.mul(P62)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "v = v * power of two", _time
+
+ t = time()
+ v2 = rbigint.fromint(2**8)
+ for n in xrange(28):
+ v2 = v2.mul(v2)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "v = v * v", _time
+
+ t = time()
+ v3 = rbigint.fromint(2**62)
+ for n in xrange(500000):
+ v3 = v3.add(v3)
+
+
+ _time = time() - t
+ sumTime += _time
+ print "v = v + v", _time
+
+ print "Sum: ", sumTime
+
+ return 0
+
+# _____ Define and setup target ___
+
+def target(*args):
+ return entry_point, None
+
+if __name__ == '__main__':
+ import sys
+ res = entry_point(sys.argv)
+ sys.exit(res)
diff --git a/pypy/translator/jvm/test/test_unicode.py b/pypy/translator/jvm/test/test_unicode.py
--- a/pypy/translator/jvm/test/test_unicode.py
+++ b/pypy/translator/jvm/test/test_unicode.py
@@ -30,3 +30,6 @@
return const
res = self.interpret(fn, [])
assert res == const
+
+ def test_strformat_unicode_arg(self):
+ py.test.skip('fixme!')
More information about the pypy-commit
mailing list