[pypy-commit] pypy s390x-backend: merged default
plan_rich
pypy.commits at gmail.com
Wed Jan 20 04:08:59 EST 2016
Author: Richard Plangger <planrichi at gmail.com>
Branch: s390x-backend
Changeset: r81874:fc1bb01e3b26
Date: 2016-01-20 10:08 +0100
http://bitbucket.org/pypy/pypy/changeset/fc1bb01e3b26/
Log: merged default
diff --git a/pypy/doc/how-to-contribute.rst b/pypy/doc/how-to-contribute.rst
--- a/pypy/doc/how-to-contribute.rst
+++ b/pypy/doc/how-to-contribute.rst
@@ -67,8 +67,8 @@
**module** directory contains extension modules written in RPython
* **rpython compiler** that resides in ``rpython/annotator`` and
- ``rpython/rtyper`` directories. Consult :doc:`introduction to RPython <getting-started-dev>` for
- further reading
+ ``rpython/rtyper`` directories. Consult `Getting Started with RPython`_
+ for further reading
* **JIT generator** lives in ``rpython/jit`` directory. optimizations live
in ``rpython/jit/metainterp/optimizeopt``, the main JIT in
@@ -80,3 +80,14 @@
The rest of directories serve specific niche goal and are unlikely a good
entry point.
+
+
+More documentation
+------------------
+
+* `Getting Started Developing With PyPy`_
+
+* `Getting Started with RPython`_
+
+.. _`Getting Started Developing With PyPy`: getting-started-dev.html
+.. _`Getting started with RPython`: http://rpython.readthedocs.org/en/latest/getting-started.html
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
@@ -120,7 +120,7 @@
Updated to CFFI 1.5, which supports a new way to do embedding.
Deprecates http://pypy.readthedocs.org/en/latest/embedding.html.
-.. branch fix-cpython-ssl-tests-2.7
+.. branch: fix-cpython-ssl-tests-2.7
Fix SSL tests by importing cpython's patch
diff --git a/pypy/module/cpyext/Doc_stubgen_enable.patch b/pypy/module/cpyext/patches/Doc_stubgen_enable.patch
rename from pypy/module/cpyext/Doc_stubgen_enable.patch
rename to pypy/module/cpyext/patches/Doc_stubgen_enable.patch
diff --git a/pypy/objspace/std/mapdict.py b/pypy/objspace/std/mapdict.py
--- a/pypy/objspace/std/mapdict.py
+++ b/pypy/objspace/std/mapdict.py
@@ -30,10 +30,10 @@
assert isinstance(terminator, Terminator)
self.terminator = terminator
- def read(self, obj, selector):
- attr = self.find_map_attr(selector)
+ def read(self, obj, name, index):
+ attr = self.find_map_attr(name, index)
if attr is None:
- return self.terminator._read_terminator(obj, selector)
+ return self.terminator._read_terminator(obj, name, index)
if (
jit.isconstant(attr.storageindex) and
jit.isconstant(obj) and
@@ -47,39 +47,39 @@
def _pure_mapdict_read_storage(self, obj, storageindex):
return obj._mapdict_read_storage(storageindex)
- def write(self, obj, selector, w_value):
- attr = self.find_map_attr(selector)
+ def write(self, obj, name, index, w_value):
+ attr = self.find_map_attr(name, index)
if attr is None:
- return self.terminator._write_terminator(obj, selector, w_value)
+ return self.terminator._write_terminator(obj, name, index, w_value)
if not attr.ever_mutated:
attr.ever_mutated = True
obj._mapdict_write_storage(attr.storageindex, w_value)
return True
- def delete(self, obj, selector):
+ def delete(self, obj, name, index):
pass
- def find_map_attr(self, selector):
+ def find_map_attr(self, name, index):
if jit.we_are_jitted():
# hack for the jit:
# the _find_map_attr method is pure too, but its argument is never
# constant, because it is always a new tuple
- return self._find_map_attr_jit_pure(selector[0], selector[1])
+ return self._find_map_attr_jit_pure(name, index)
else:
- return self._find_map_attr_indirection(selector)
+ return self._find_map_attr_indirection(name, index)
@jit.elidable
def _find_map_attr_jit_pure(self, name, index):
- return self._find_map_attr_indirection((name, index))
+ return self._find_map_attr_indirection(name, index)
@jit.dont_look_inside
- def _find_map_attr_indirection(self, selector):
+ def _find_map_attr_indirection(self, name, index):
if (self.space.config.objspace.std.withmethodcache):
- return self._find_map_attr_cache(selector)
- return self._find_map_attr(selector)
+ return self._find_map_attr_cache(name, index)
+ return self._find_map_attr(name, index)
@jit.dont_look_inside
- def _find_map_attr_cache(self, selector):
+ def _find_map_attr_cache(self, name, index):
space = self.space
cache = space.fromcache(MapAttrCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
@@ -87,31 +87,36 @@
attrs_as_int = objectmodel.current_object_addr_as_int(self)
# ^^^Note: see comment in typeobject.py for
# _pure_lookup_where_with_method_cache()
- hash_selector = objectmodel.compute_hash(selector)
+
+ # unrolled hash computation for 2-tuple
+ c1 = 0x345678
+ c2 = 1000003
+ hash_name = objectmodel.compute_hash(name)
+ hash_selector = intmask((c2 * ((c2 * c1) ^ hash_name)) ^ index)
product = intmask(attrs_as_int * hash_selector)
attr_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: same comment too
cached_attr = cache.attrs[attr_hash]
if cached_attr is self:
- cached_selector = cache.selectors[attr_hash]
- if cached_selector == selector:
+ cached_name = cache.names[attr_hash]
+ cached_index = cache.indexes[attr_hash]
+ if cached_name == name and cached_index == index:
attr = cache.cached_attrs[attr_hash]
if space.config.objspace.std.withmethodcachecounter:
- name = selector[0]
cache.hits[name] = cache.hits.get(name, 0) + 1
return attr
- attr = self._find_map_attr(selector)
+ attr = self._find_map_attr(name, index)
cache.attrs[attr_hash] = self
- cache.selectors[attr_hash] = selector
+ cache.names[attr_hash] = name
+ cache.indexes[attr_hash] = index
cache.cached_attrs[attr_hash] = attr
if space.config.objspace.std.withmethodcachecounter:
- name = selector[0]
cache.misses[name] = cache.misses.get(name, 0) + 1
return attr
- def _find_map_attr(self, selector):
+ def _find_map_attr(self, name, index):
while isinstance(self, PlainAttribute):
- if selector == self.selector:
+ if name == self.name and index == self.index:
return self
self = self.back
return None
@@ -137,23 +142,22 @@
@jit.elidable
def _get_new_attr(self, name, index):
- selector = name, index
cache = self.cache_attrs
if cache is None:
cache = self.cache_attrs = {}
- attr = cache.get(selector, None)
+ attr = cache.get((name, index), None)
if attr is None:
- attr = PlainAttribute(selector, self)
- cache[selector] = attr
+ attr = PlainAttribute(name, index, self)
+ cache[name, index] = attr
return attr
- @jit.look_inside_iff(lambda self, obj, selector, w_value:
+ @jit.look_inside_iff(lambda self, obj, name, index, w_value:
jit.isconstant(self) and
- jit.isconstant(selector[0]) and
- jit.isconstant(selector[1]))
- def add_attr(self, obj, selector, w_value):
+ jit.isconstant(name) and
+ jit.isconstant(index))
+ def add_attr(self, obj, name, index, w_value):
# grumble, jit needs this
- attr = self._get_new_attr(selector[0], selector[1])
+ attr = self._get_new_attr(name, index)
oldattr = obj._get_mapdict_map()
if not jit.we_are_jitted():
size_est = (oldattr._size_estimate + attr.size_estimate()
@@ -189,11 +193,11 @@
AbstractAttribute.__init__(self, space, self)
self.w_cls = w_cls
- def _read_terminator(self, obj, selector):
+ def _read_terminator(self, obj, name, index):
return None
- def _write_terminator(self, obj, selector, w_value):
- obj._get_mapdict_map().add_attr(obj, selector, w_value)
+ def _write_terminator(self, obj, name, index, w_value):
+ obj._get_mapdict_map().add_attr(obj, name, index, w_value)
return True
def copy(self, obj):
@@ -231,40 +235,40 @@
class NoDictTerminator(Terminator):
- def _write_terminator(self, obj, selector, w_value):
- if selector[1] == DICT:
+ def _write_terminator(self, obj, name, index, w_value):
+ if index == DICT:
return False
- return Terminator._write_terminator(self, obj, selector, w_value)
+ return Terminator._write_terminator(self, obj, name, index, w_value)
class DevolvedDictTerminator(Terminator):
- def _read_terminator(self, obj, selector):
- if selector[1] == DICT:
+ def _read_terminator(self, obj, name, index):
+ if index == DICT:
space = self.space
w_dict = obj.getdict(space)
- return space.finditem_str(w_dict, selector[0])
- return Terminator._read_terminator(self, obj, selector)
+ return space.finditem_str(w_dict, name)
+ return Terminator._read_terminator(self, obj, name, index)
- def _write_terminator(self, obj, selector, w_value):
- if selector[1] == DICT:
+ def _write_terminator(self, obj, name, index, w_value):
+ if index == DICT:
space = self.space
w_dict = obj.getdict(space)
- space.setitem_str(w_dict, selector[0], w_value)
+ space.setitem_str(w_dict, name, w_value)
return True
- return Terminator._write_terminator(self, obj, selector, w_value)
+ return Terminator._write_terminator(self, obj, name, index, w_value)
- def delete(self, obj, selector):
+ def delete(self, obj, name, index):
from pypy.interpreter.error import OperationError
- if selector[1] == DICT:
+ if index == DICT:
space = self.space
w_dict = obj.getdict(space)
try:
- space.delitem(w_dict, space.wrap(selector[0]))
+ space.delitem(w_dict, space.wrap(name))
except OperationError, ex:
if not ex.match(space, space.w_KeyError):
raise
return Terminator.copy(self, obj)
- return Terminator.delete(self, obj, selector)
+ return Terminator.delete(self, obj, name, index)
def remove_dict_entries(self, obj):
assert 0, "should be unreachable"
@@ -276,27 +280,28 @@
return Terminator.set_terminator(self, obj, terminator)
class PlainAttribute(AbstractAttribute):
- _immutable_fields_ = ['selector', 'storageindex', 'back', 'ever_mutated?']
+ _immutable_fields_ = ['name', 'index', 'storageindex', 'back', 'ever_mutated?']
- def __init__(self, selector, back):
+ def __init__(self, name, index, back):
AbstractAttribute.__init__(self, back.space, back.terminator)
- self.selector = selector
+ self.name = name
+ self.index = index
self.storageindex = back.length()
self.back = back
self._size_estimate = self.length() * NUM_DIGITS_POW2
self.ever_mutated = False
def _copy_attr(self, obj, new_obj):
- w_value = self.read(obj, self.selector)
- new_obj._get_mapdict_map().add_attr(new_obj, self.selector, w_value)
+ w_value = self.read(obj, self.name, self.index)
+ new_obj._get_mapdict_map().add_attr(new_obj, self.name, self.index, w_value)
- def delete(self, obj, selector):
- if selector == self.selector:
+ def delete(self, obj, name, index):
+ if name == self.name and index == self.index:
# ok, attribute is deleted
if not self.ever_mutated:
self.ever_mutated = True
return self.back.copy(obj)
- new_obj = self.back.delete(obj, selector)
+ new_obj = self.back.delete(obj, name, index)
if new_obj is not None:
self._copy_attr(obj, new_obj)
return new_obj
@@ -315,14 +320,14 @@
return new_obj
def search(self, attrtype):
- if self.selector[1] == attrtype:
+ if self.index == attrtype:
return self
return self.back.search(attrtype)
def materialize_r_dict(self, space, obj, dict_w):
new_obj = self.back.materialize_r_dict(space, obj, dict_w)
- if self.selector[1] == DICT:
- w_attr = space.wrap(self.selector[0])
+ if self.index == DICT:
+ w_attr = space.wrap(self.name)
dict_w[w_attr] = obj._mapdict_read_storage(self.storageindex)
else:
self._copy_attr(obj, new_obj)
@@ -330,12 +335,12 @@
def remove_dict_entries(self, obj):
new_obj = self.back.remove_dict_entries(obj)
- if self.selector[1] != DICT:
+ if self.index != DICT:
self._copy_attr(obj, new_obj)
return new_obj
def __repr__(self):
- return "<PlainAttribute %s %s %r>" % (self.selector, self.storageindex, self.back)
+ return "<PlainAttribute %s %s %s %r>" % (self.name, self.index, self.storageindex, self.back)
def _become(w_obj, new_obj):
# this is like the _become method, really, but we cannot use that due to
@@ -347,8 +352,8 @@
assert space.config.objspace.std.withmethodcache
SIZE = 1 << space.config.objspace.std.methodcachesizeexp
self.attrs = [None] * SIZE
- self._empty_selector = (None, INVALID)
- self.selectors = [self._empty_selector] * SIZE
+ self.names = [None] * SIZE
+ self.indexes = [INVALID] * SIZE
self.cached_attrs = [None] * SIZE
if space.config.objspace.std.withmethodcachecounter:
self.hits = {}
@@ -357,8 +362,9 @@
def clear(self):
for i in range(len(self.attrs)):
self.attrs[i] = None
- for i in range(len(self.selectors)):
- self.selectors[i] = self._empty_selector
+ for i in range(len(self.names)):
+ self.names[i] = None
+ self.indexes[i] = INVALID
for i in range(len(self.cached_attrs)):
self.cached_attrs[i] = None
@@ -388,20 +394,20 @@
# objspace interface
def getdictvalue(self, space, attrname):
- return self._get_mapdict_map().read(self, (attrname, DICT))
+ return self._get_mapdict_map().read(self, attrname, DICT)
def setdictvalue(self, space, attrname, w_value):
- return self._get_mapdict_map().write(self, (attrname, DICT), w_value)
+ return self._get_mapdict_map().write(self, attrname, DICT, w_value)
def deldictvalue(self, space, attrname):
- new_obj = self._get_mapdict_map().delete(self, (attrname, DICT))
+ new_obj = self._get_mapdict_map().delete(self, attrname, DICT)
if new_obj is None:
return False
self._become(new_obj)
return True
def getdict(self, space):
- w_dict = self._get_mapdict_map().read(self, ("dict", SPECIAL))
+ w_dict = self._get_mapdict_map().read(self, "dict", SPECIAL)
if w_dict is not None:
assert isinstance(w_dict, W_DictMultiObject)
return w_dict
@@ -409,7 +415,7 @@
strategy = space.fromcache(MapDictStrategy)
storage = strategy.erase(self)
w_dict = W_DictObject(space, strategy, storage)
- flag = self._get_mapdict_map().write(self, ("dict", SPECIAL), w_dict)
+ flag = self._get_mapdict_map().write(self, "dict", SPECIAL, w_dict)
assert flag
return w_dict
@@ -425,7 +431,7 @@
# shell that continues to delegate to 'self'.
if type(w_olddict.get_strategy()) is MapDictStrategy:
w_olddict.get_strategy().switch_to_object_strategy(w_olddict)
- flag = self._get_mapdict_map().write(self, ("dict", SPECIAL), w_dict)
+ flag = self._get_mapdict_map().write(self, "dict", SPECIAL, w_dict)
assert flag
def getclass(self, space):
@@ -443,16 +449,16 @@
self._init_empty(w_subtype.terminator)
def getslotvalue(self, slotindex):
- key = ("slot", SLOTS_STARTING_FROM + slotindex)
- return self._get_mapdict_map().read(self, key)
+ index = SLOTS_STARTING_FROM + slotindex
+ return self._get_mapdict_map().read(self, "slot", index)
def setslotvalue(self, slotindex, w_value):
- key = ("slot", SLOTS_STARTING_FROM + slotindex)
- self._get_mapdict_map().write(self, key, w_value)
+ index = SLOTS_STARTING_FROM + slotindex
+ self._get_mapdict_map().write(self, "slot", index, w_value)
def delslotvalue(self, slotindex):
- key = ("slot", SLOTS_STARTING_FROM + slotindex)
- new_obj = self._get_mapdict_map().delete(self, key)
+ index = SLOTS_STARTING_FROM + slotindex
+ new_obj = self._get_mapdict_map().delete(self, "slot", index)
if new_obj is None:
return False
self._become(new_obj)
@@ -462,7 +468,7 @@
def getweakref(self):
from pypy.module._weakref.interp__weakref import WeakrefLifeline
- lifeline = self._get_mapdict_map().read(self, ("weakref", SPECIAL))
+ lifeline = self._get_mapdict_map().read(self, "weakref", SPECIAL)
if lifeline is None:
return None
assert isinstance(lifeline, WeakrefLifeline)
@@ -472,11 +478,11 @@
def setweakref(self, space, weakreflifeline):
from pypy.module._weakref.interp__weakref import WeakrefLifeline
assert isinstance(weakreflifeline, WeakrefLifeline)
- self._get_mapdict_map().write(self, ("weakref", SPECIAL), weakreflifeline)
+ self._get_mapdict_map().write(self, "weakref", SPECIAL, weakreflifeline)
setweakref._cannot_really_call_random_things_ = True
def delweakref(self):
- self._get_mapdict_map().write(self, ("weakref", SPECIAL), None)
+ self._get_mapdict_map().write(self, "weakref", SPECIAL, None)
delweakref._cannot_really_call_random_things_ = True
class ObjectMixin(object):
@@ -721,7 +727,7 @@
curr = self.unerase(w_dict.dstorage)._get_mapdict_map().search(DICT)
if curr is None:
raise KeyError
- key = curr.selector[0]
+ key = curr.name
w_value = self.getitem_str(w_dict, key)
w_key = self.space.wrap(key)
self.delitem(w_dict, w_key)
@@ -758,7 +764,7 @@
curr_map = self.curr_map.search(DICT)
if curr_map:
self.curr_map = curr_map.back
- attr = curr_map.selector[0]
+ attr = curr_map.name
w_attr = self.space.wrap(attr)
return w_attr
return None
@@ -780,7 +786,7 @@
curr_map = self.curr_map.search(DICT)
if curr_map:
self.curr_map = curr_map.back
- attr = curr_map.selector[0]
+ attr = curr_map.name
return self.w_obj.getdictvalue(self.space, attr)
return None
@@ -801,7 +807,7 @@
curr_map = self.curr_map.search(DICT)
if curr_map:
self.curr_map = curr_map.back
- attr = curr_map.selector[0]
+ attr = curr_map.name
w_attr = self.space.wrap(attr)
return w_attr, self.w_obj.getdictvalue(self.space, attr)
return None, None
@@ -884,9 +890,9 @@
_, w_descr = w_type._pure_lookup_where_possibly_with_method_cache(
name, version_tag)
#
- selector = ("", INVALID)
+ attrname, index = ("", INVALID)
if w_descr is None:
- selector = (name, DICT) # common case: no such attr in the class
+ attrname, index = (name, DICT) # common case: no such attr in the class
elif isinstance(w_descr, MutableCell):
pass # we have a MutableCell in the class: give up
elif space.is_data_descr(w_descr):
@@ -894,20 +900,21 @@
# (if any) has no relevance.
from pypy.interpreter.typedef import Member
if isinstance(w_descr, Member): # it is a slot -- easy case
- selector = ("slot", SLOTS_STARTING_FROM + w_descr.index)
+ attrname, index = ("slot", SLOTS_STARTING_FROM + w_descr.index)
else:
# There is a non-data descriptor in the class. If there is
# also a dict attribute, use the latter, caching its storageindex.
# If not, we loose. We could do better in this case too,
# but we don't care too much; the common case of a method
# invocation is handled by LOOKUP_METHOD_xxx below.
- selector = (name, DICT)
+ attrname = name
+ index = DICT
#
- if selector[1] != INVALID:
- attr = map.find_map_attr(selector)
+ if index != INVALID:
+ attr = map.find_map_attr(attrname, index)
if attr is not None:
# Note that if map.terminator is a DevolvedDictTerminator,
- # map.find_map_attr will always return None if selector[1]==DICT.
+ # map.find_map_attr will always return None if index==DICT.
_fill_cache(pycode, nameindex, map, version_tag, attr.storageindex)
return w_obj._mapdict_read_storage(attr.storageindex)
if space.config.objspace.std.withmethodcachecounter:
diff --git a/pypy/objspace/std/test/test_mapdict.py b/pypy/objspace/std/test/test_mapdict.py
--- a/pypy/objspace/std/test/test_mapdict.py
+++ b/pypy/objspace/std/test/test_mapdict.py
@@ -34,8 +34,8 @@
def test_plain_attribute():
w_cls = "class"
- aa = PlainAttribute(("b", DICT),
- PlainAttribute(("a", DICT),
+ aa = PlainAttribute("b", DICT,
+ PlainAttribute("a", DICT,
Terminator(space, w_cls)))
assert aa.space is space
assert aa.terminator.w_cls is w_cls
@@ -63,16 +63,16 @@
def test_huge_chain():
current = Terminator(space, "cls")
for i in range(20000):
- current = PlainAttribute((str(i), DICT), current)
- assert current.find_map_attr(("0", DICT)).storageindex == 0
+ current = PlainAttribute(str(i), DICT, current)
+ assert current.find_map_attr("0", DICT).storageindex == 0
def test_search():
- aa = PlainAttribute(("b", DICT), PlainAttribute(("a", DICT), Terminator(None, None)))
+ aa = PlainAttribute("b", DICT, PlainAttribute("a", DICT, Terminator(None, None)))
assert aa.search(DICT) is aa
assert aa.search(SLOTS_STARTING_FROM) is None
assert aa.search(SPECIAL) is None
- bb = PlainAttribute(("C", SPECIAL), PlainAttribute(("A", SLOTS_STARTING_FROM), aa))
+ bb = PlainAttribute("C", SPECIAL, PlainAttribute("A", SLOTS_STARTING_FROM, aa))
assert bb.search(DICT) is aa
assert bb.search(SLOTS_STARTING_FROM) is bb.back
assert bb.search(SPECIAL) is bb
@@ -320,7 +320,7 @@
d = {}
w_d = FakeDict(d)
- flag = obj.map.write(obj, ("dict", SPECIAL), w_d)
+ flag = obj.map.write(obj, "dict", SPECIAL, w_d)
assert flag
materialize_r_dict(space, obj, d)
assert d == {"a": 5, "b": 6, "c": 7}
More information about the pypy-commit
mailing list