def fn():
d2 = D()
return (compute_hash(d2),
current_object_addr_as_int(d2),
compute_hash(c),
compute_hash(d),
compute_hash(("Hi", None, (7.5, 2, d))))
def f1():
d2 = D()
# xxx we assume that current_object_addr_as_int is defined as
# simply returning the identity hash
current_identityhash = current_object_addr_as_int(d2)
instance_hash = compute_identity_hash(d2)
return current_identityhash == instance_hash
def _index_cache(self, selector):
space = self.space
cache = space.fromcache(IndexCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
SHIFT1 = SHIFT2 - 5
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)
product = intmask(attrs_as_int * hash_selector)
index_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: same comment too
cached_attr = cache.attrs[index_hash]
if cached_attr is self:
cached_selector = cache.selectors[index_hash]
if cached_selector == selector:
index = cache.indices[index_hash]
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.hits[name] = cache.hits.get(name, 0) + 1
return index
index = self._index(selector)
cache.attrs[index_hash] = self
cache.selectors[index_hash] = selector
cache.indices[index_hash] = index
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.misses[name] = cache.misses.get(name, 0) + 1
return index
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
SHIFT = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
version_tag_as_int = current_object_addr_as_int(version_tag)
# ^^^Note: if the version_tag object is moved by a moving GC, the
# existing method cache entries won't be found any more; new
# entries will be created based on the new address. The
# assumption is that the version_tag object won't keep moving all
# the time - so using the fast current_object_addr_as_int() instead
# of a slower solution like hash() is still a good trade-off.
hash_name = compute_hash(name)
method_hash = r_uint(intmask(version_tag_as_int * hash_name)) >> SHIFT
cached_version_tag = space.method_cache_versions[method_hash]
if cached_version_tag is version_tag:
cached_name = space.method_cache_names[method_hash]
if cached_name is name:
tup = space.method_cache_lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_hits[name] = \
space.method_cache_hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where(name)
space.method_cache_versions[method_hash] = version_tag
space.method_cache_names[method_hash] = name
space.method_cache_lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_misses[name] = \
space.method_cache_misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def fn():
d2 = D()
return (compute_hash(d2),
current_object_addr_as_int(d2),
compute_hash(c),
compute_hash(d),
compute_hash(("Hi", None, (7.5, 2, d))))
def f1():
d2 = D()
# xxx we assume that current_object_addr_as_int is defined as
# simply returning the identity hash
current_identityhash = current_object_addr_as_int(d2)
instance_hash = compute_identity_hash(d2)
return current_identityhash == instance_hash
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
SHIFT = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
version_tag_as_int = current_object_addr_as_int(version_tag)
# ^^^Note: if the version_tag object is moved by a moving GC, the
# existing method cache entries won't be found any more; new
# entries will be created based on the new address. The
# assumption is that the version_tag object won't keep moving all
# the time - so using the fast current_object_addr_as_int() instead
# of a slower solution like hash() is still a good trade-off.
hash_name = compute_hash(name)
method_hash = r_uint(intmask(version_tag_as_int * hash_name)) >> SHIFT
cached_version_tag = space.method_cache_versions[method_hash]
if cached_version_tag is version_tag:
cached_name = space.method_cache_names[method_hash]
if cached_name is name:
tup = space.method_cache_lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_hits[name] = \
space.method_cache_hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where_all_typeobjects(name)
space.method_cache_versions[method_hash] = version_tag
space.method_cache_names[method_hash] = name
space.method_cache_lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
space.method_cache_misses[name] = \
space.method_cache_misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def _index_cache(self, selector):
space = self.space
cache = space.fromcache(IndexCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
SHIFT1 = SHIFT2 - 5
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)
product = intmask(attrs_as_int * hash_selector)
index_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: same comment too
cached_attr = cache.attrs[index_hash]
if cached_attr is self:
cached_selector = cache.selectors[index_hash]
if cached_selector == selector:
index = cache.indices[index_hash]
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.hits[name] = cache.hits.get(name, 0) + 1
return index
index = self._index(selector)
cache.attrs[index_hash] = self
cache.selectors[index_hash] = selector
cache.indices[index_hash] = index
if space.config.objspace.std.withmethodcachecounter:
name = selector[0]
cache.misses[name] = cache.misses.get(name, 0) + 1
return index
def f1():
d2 = D()
# xxx we assume that the identityhash doesn't change from
# one line to the next
current_identityhash = current_object_addr_as_int(d2)
instance_hash = hash(d2)
return ((current_identityhash & sys.maxint) ==
(instance_hash & sys.maxint))
def f():
d2 = D()
return (
compute_identity_hash(d2),
current_object_addr_as_int(d2),
compute_identity_hash(c),
compute_identity_hash(d),
)
def f1():
d2 = D()
# xxx we assume that the identityhash doesn't change from
# one line to the next
current_identityhash = current_object_addr_as_int(d2)
instance_hash = hash(d2)
return ((current_identityhash & sys.maxint) == (instance_hash
& sys.maxint))
def entry_point(loops):
g = rpystone.g
g.IntGlob = 0
g.BoolGlob = 0
g.Char1Glob = '\0'
g.Char2Glob = '\0'
for i in range(51):
g.Array1Glob[i] = 0
for i in range(51):
for j in range(51):
g.Array2Glob[i][j] = 0
g.PtrGlb = None
g.PtrGlbNext = None
return rpystone.pystones(loops), current_object_addr_as_int(g)
def entry_point(loops):
g = rpystone.g
g.IntGlob = 0
g.BoolGlob = 0
g.Char1Glob = "\0"
g.Char2Glob = "\0"
for i in range(51):
g.Array1Glob[i] = 0
for i in range(51):
for j in range(51):
g.Array2Glob[i][j] = 0
g.PtrGlb = None
g.PtrGlbNext = None
return rpystone.pystones(loops), current_object_addr_as_int(g)
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
cache = space.fromcache(MethodCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
SHIFT1 = SHIFT2 - 5
version_tag_as_int = current_object_addr_as_int(version_tag)
# ^^^Note: if the version_tag object is moved by a moving GC, the
# existing method cache entries won't be found any more; new
# entries will be created based on the new address. The
# assumption is that the version_tag object won't keep moving all
# the time - so using the fast current_object_addr_as_int() instead
# of a slower solution like hash() is still a good trade-off.
hash_name = compute_hash(name)
product = intmask(version_tag_as_int * hash_name)
method_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: we used to just take product>>SHIFT2, but on 64-bit
# platforms SHIFT2 is really large, and we loose too much information
# that way (as shown by failures of the tests that typically have
# method names like 'f' who hash to a number that has only ~33 bits).
cached_version_tag = cache.versions[method_hash]
if cached_version_tag is version_tag:
cached_name = cache.names[method_hash]
if cached_name is name:
tup = cache.lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
cache.hits[name] = cache.hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where_all_typeobjects(name)
cache.versions[method_hash] = version_tag
cache.names[method_hash] = name
cache.lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
cache.misses[name] = cache.misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def _pure_lookup_where_with_method_cache(w_self, name, version_tag):
space = w_self.space
cache = space.fromcache(MethodCache)
SHIFT2 = r_uint.BITS - space.config.objspace.std.methodcachesizeexp
SHIFT1 = SHIFT2 - 5
version_tag_as_int = current_object_addr_as_int(version_tag)
# ^^^Note: if the version_tag object is moved by a moving GC, the
# existing method cache entries won't be found any more; new
# entries will be created based on the new address. The
# assumption is that the version_tag object won't keep moving all
# the time - so using the fast current_object_addr_as_int() instead
# of a slower solution like hash() is still a good trade-off.
hash_name = compute_hash(name)
product = intmask(version_tag_as_int * hash_name)
method_hash = (r_uint(product) ^ (r_uint(product) << SHIFT1)) >> SHIFT2
# ^^^Note2: we used to just take product>>SHIFT2, but on 64-bit
# platforms SHIFT2 is really large, and we loose too much information
# that way (as shown by failures of the tests that typically have
# method names like 'f' who hash to a number that has only ~33 bits).
cached_version_tag = cache.versions[method_hash]
if cached_version_tag is version_tag:
cached_name = cache.names[method_hash]
if cached_name is name:
tup = cache.lookup_where[method_hash]
if space.config.objspace.std.withmethodcachecounter:
cache.hits[name] = cache.hits.get(name, 0) + 1
# print "hit", w_self, name
return tup
tup = w_self._lookup_where_all_typeobjects(name)
cache.versions[method_hash] = version_tag
cache.names[method_hash] = name
cache.lookup_where[method_hash] = tup
if space.config.objspace.std.withmethodcachecounter:
cache.misses[name] = cache.misses.get(name, 0) + 1
# print "miss", w_self, name
return tup
def fn():
a1 = A()
a2 = A()
return (compute_unique_id(a1), current_object_addr_as_int(a1),
compute_unique_id(a2), current_object_addr_as_int(a2))
def f():
d2 = D()
return (compute_identity_hash(d2), current_object_addr_as_int(d2),
compute_identity_hash(c), compute_identity_hash(d))
def f():
x = FooBar()
# on lltype, the RPython-level repr of an instance contains the
# current object address
return current_object_addr_as_int(x), str(x)
def fn():
d2 = D()
return hash(d2), current_object_addr_as_int(d2), hash(c), hash(d)
def fn():
a1 = A()
a2 = A()
return (compute_unique_id(a1), current_object_addr_as_int(a1),
compute_unique_id(a2), current_object_addr_as_int(a2))
def f():
x = FooBar()
# on lltype, the RPython-level repr of an instance contains the
# current object address
return current_object_addr_as_int(x), str(x)
def fn():
d2 = D()
return hash(d2), current_object_addr_as_int(d2), hash(c), hash(d)