def _make_jitcell_getter_default(self):
"NOT_RPYTHON"
jitdriver_sd = self.jitdriver_sd
green_args_spec = unrolling_iterable(jitdriver_sd._green_args_spec)
#
def comparekey(greenargs1, greenargs2):
i = 0
for TYPE in green_args_spec:
if not equal_whatever(TYPE, greenargs1[i], greenargs2[i]):
return False
i = i + 1
return True
#
def hashkey(greenargs):
x = 0x345678
i = 0
for TYPE in green_args_spec:
item = greenargs[i]
y = hash_whatever(TYPE, item)
x = intmask((1000003 * x) ^ y)
i = i + 1
return x
#
jitcell_dict = r_dict(comparekey, hashkey)
#
def get_jitcell(build, *greenargs):
try:
cell = jitcell_dict[greenargs]
except KeyError:
if not build:
return None
cell = JitCell()
jitcell_dict[greenargs] = cell
return cell
return get_jitcell
def func(i):
d = r_dict(eq, rhash, force_non_null=True)
if not i:
d[None] = i
else:
d[str(i)] = i
return "12" in d, d
def func(i):
d = r_dict(eq, rhash, force_non_null=True)
if not i:
d[None] = i
else:
d[str(i)] = i
return "12" in d, d
def _make_jitcell_getter_default(self, JitCell):
"NOT_RPYTHON"
warmrunnerdesc = self.warmrunnerdesc
green_args_spec = unrolling_iterable(warmrunnerdesc.green_args_spec)
#
def comparekey(greenargs1, greenargs2):
i = 0
for TYPE in green_args_spec:
if not equal_whatever(TYPE, greenargs1[i], greenargs2[i]):
return False
i = i + 1
return True
#
def hashkey(greenargs):
x = 0x345678
i = 0
for TYPE in green_args_spec:
item = greenargs[i]
y = hash_whatever(TYPE, item)
x = intmask((1000003 * x) ^ y)
i = i + 1
return x
#
jitcell_dict = r_dict(comparekey, hashkey)
#
def get_jitcell(*greenargs):
try:
cell = jitcell_dict[greenargs]
except KeyError:
cell = JitCell()
jitcell_dict[greenargs] = cell
return cell
return get_jitcell
def test_customdict_circular(self):
from pypy.rlib.objectmodel import r_dict
def key_eq(a, b):
return a.x[0] == b.x[0]
def key_hash(a):
return ord(a.x[0])
class A:
def __init__(self, x):
self.x = x
a = A('foo')
a.dict = r_dict(key_eq, key_hash)
a.dict[a] = 42
def fn(b):
if b:
s = A('foo')
else:
s = A('bar')
return a.dict[s]
assert self.interpret(fn, [True]) == 42
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = dct.get(total, 0) + 1
total -= 1
return dct[0]
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
d1["blabla"] = 2
except TypeError:
return 42
return 0
def f(n):
d = r_dict(myeq, myhash)
for i in range(10):
d[i] = i*i
try:
return d[n]
except FooError:
return 99
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
x = d1["blabla"]
except Exception:
return 42
return x
def f(n):
d = r_dict(myeq, myhash)
for i in range(10):
d[i] = i * i
try:
return d[n]
except FooError:
return 99
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
x = d1["blabla"]
except Exception:
return 42
return x
def f():
d1 = r_dict(eq, raising_hash)
d1['xxx'] = 1
try:
d1["blabla"] = 2
except TypeError:
return 42
return 0
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
dct[total] = dct.get(total, 0) + 1
total -= 1
return dct[0]
def f(n):
d = None
while n > 0:
myjitdriver.jit_merge_point(n=n, d=d)
d = objectmodel.r_dict(eq_func, hash_func)
y = Wrapper(str(n))
d[y] = n - 1
n = d[y]
return d[Wrapper(str(n + 1))]
def f(n):
d = None
while n > 0:
myjitdriver.jit_merge_point(n=n, d=d)
d = objectmodel.r_dict(eq_func, hash_func)
y = Wrapper(str(n))
d[y] = n - 1
n = d[y]
return d[Wrapper(str(n + 1))]
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
if total not in dct:
dct[total] = []
dct[total].append(total)
total -= 1
return len(dct[0])
def f(n):
dct = objectmodel.r_dict(eq, key)
total = n
while total:
myjitdriver.jit_merge_point(total=total, dct=dct)
if total not in dct:
dct[total] = []
dct[total].append(total)
total -= 1
return len(dct[0])
def make_setdata_from_w_iterable(space, w_iterable=None):
data = r_dict(space.eq_w, space.hash_w)
if w_iterable is not None:
w_iterator = space.iter(w_iterable)
while True:
try:
w_item = space.next(w_iterator)
except OperationError, e:
if not e.match(space, space.w_StopIteration):
raise
break
data[w_item] = None
def make_setdata_from_w_iterable(space, w_iterable=None):
data = r_dict(space.eq_w, space.hash_w)
if w_iterable is not None:
w_iterator = space.iter(w_iterable)
while True:
try:
w_item = space.next(w_iterator)
except OperationError, e:
if not e.match(space, space.w_StopIteration):
raise
break
data[w_item] = None
def func():
d = r_dict(deq, dhash)
d[5] = 2
d[6] = 3
k1, v1 = d.popitem()
assert len(d) == 1
k2, v2 = d.popitem()
try:
d.popitem()
except KeyError:
pass
else:
assert 0, "should have raised KeyError"
assert len(d) == 0
return k1*1000 + v1*100 + k2*10 + v2
def func():
d = r_dict(deq, dhash)
d[5] = 2
d[6] = 3
k1, v1 = d.popitem()
assert len(d) == 1
k2, v2 = d.popitem()
try:
d.popitem()
except KeyError:
pass
else:
assert 0, "should have raised KeyError"
assert len(d) == 0
return k1*1000 + v1*100 + k2*10 + v2
def test_constant_r_dict(self):
def strange_key_eq(key1, key2):
return key1[0] == key2[0] # only the 1st character is relevant
def strange_key_hash(key):
return ord(key[0])
d = r_dict(strange_key_eq, strange_key_hash)
d['hello'] = 42
d['world'] = 43
for x in range(65, 91):
d[chr(x)] = x*x
def func(i):
return d[chr(i)]
res = self.interpret(func, [ord('h')])
assert res == 42
res = self.interpret(func, [ord('w')])
assert res == 43
for x in range(65, 91):
res = self.interpret(func, [x])
assert res == x*x
def test_customdict_circular(self):
from pypy.rlib.objectmodel import r_dict
def key_eq(a, b):
return a.x[0] == b.x[0]
def key_hash(a):
return ord(a.x[0])
class A:
def __init__(self, x):
self.x = x
a = A('foo')
a.dict = r_dict(key_eq, key_hash)
a.dict[a] = 42
def fn(b):
if b:
s = A('foo')
else:
s = A('bar')
return a.dict[s]
assert self.interpret(fn, [True]) == 42
def f(n):
d = r_dict(myeq, myhash)
for i in range(10):
d[i] = i * i
try:
value1 = d[n]
except FooError:
value1 = 99
try:
value2 = n in d
except FooError:
value2 = 99
try:
value3 = d[-n]
except FooError:
value3 = 99
try:
value4 = (-n) in d
except FooError:
value4 = 99
return (value1 * 1000000 + value2 * 10000 + value3 * 100 + value4)
def f(n):
d = r_dict(myeq, myhash)
for i in range(10):
d[i] = i*i
try:
value1 = d[n]
except FooError:
value1 = 99
try:
value2 = n in d
except FooError:
value2 = 99
try:
value3 = d[-n]
except FooError:
value3 = 99
try:
value4 = (-n) in d
except FooError:
value4 = 99
return (value1 * 1000000 +
value2 * 10000 +
value3 * 100 +
value4)
def get_printable_location(shapelen, sig):
return 'numpy ' + sig.debug_repr() + ' [%d dims,%s]' % (shapelen, driver_name)
return get_printable_location
def sigeq(one, two):
return one.eq(two)
def sigeq_no_numbering(one, two):
""" Cache for iterator numbering should not compare array numbers
"""
return one.eq(two, compare_array_no=False)
def sighash(sig):
return sig.hash()
known_sigs = r_dict(sigeq, sighash)
def find_sig(sig, arr):
sig.invent_array_numbering(arr)
try:
return known_sigs[sig]
except KeyError:
sig.invent_numbering()
known_sigs[sig] = sig
return sig
def _add_ptr_to_cache(ptr, cache):
i = 0
for p in cache:
if ptr == p:
return i
def __init__(w_self, space, setdata=None):
if setdata is None:
w_self.setdata = r_dict(space.eq_w, space.hash_w)
else:
w_self.setdata = setdata.copy()
def get_empty_storage(self):
new_dict = r_dict(self.space.eq_w, self.space.hash_w,
force_non_null=True)
return self.erase(new_dict)
def newset(space):
return r_dict(space.eq_w, space.hash_w, force_non_null=True)
def newset(space):
return r_dict(space.eq_w, space.hash_w, force_non_null=True)
def dict_equal_consts():
"NOT_RPYTHON"
# Returns a dict in which Consts that compare as equal
# are identified when used as keys.
return r_dict(dc_eq, dc_hash)
def args_dict_box():
return r_dict(args_eq, args_hash)
def descrlist_dict():
return r_dict(descrlist_eq, descrlist_hash)
def make_item_boxes(self):
self.item_boxes = r_dict(lleq, llhash)
def __init__(self, transitions=None):
if transitions is None:
transitions = []
self.transitions = transitions
self._states_cache = r_dict(state_eq, state_hash)
def init():
res = r_dict(space.mycmp, space.myhash)
res[obj1] = 42
res[obj2] = 43
return res
def oof():
strange = Strange()
d = r_dict(strange.key_eq, strange.key_hash)
d['x'] = 42
return d['x']
def dict_equal_consts():
"NOT_RPYTHON"
# Returns a dict in which Consts that compare as equal
# are identified when used as keys.
return r_dict(dc_eq, dc_hash)
def oof():
d = r_dict(strange_key_eq, strange_key_hash)
d['x'] = 42
return d['x']
def args_dict_box():
return r_dict(args_eq, args_hash)
def new_ref_dict_2(self):
return r_dict(rd_eq, rd_hash)
def descrlist_dict():
return r_dict(descrlist_eq, descrlist_hash)
def _make_jitcell_getter_default(self):
"NOT_RPYTHON"
jitdriver_sd = self.jitdriver_sd
green_args_spec = unrolling_iterable(jitdriver_sd._green_args_spec)
#
def comparekey(greenargs1, greenargs2):
i = 0
for TYPE in green_args_spec:
if not equal_whatever(TYPE, greenargs1[i], greenargs2[i]):
return False
i = i + 1
return True
#
def hashkey(greenargs):
x = 0x345678
i = 0
for TYPE in green_args_spec:
item = greenargs[i]
y = hash_whatever(TYPE, item)
x = intmask((1000003 * x) ^ y)
i = i + 1
return x
#
jitcell_dict = r_dict(comparekey, hashkey)
try:
self.warmrunnerdesc.stats.jitcell_dicts.append(jitcell_dict)
except AttributeError:
pass
#
def _cleanup_dict():
minimum = self.THRESHOLD_LIMIT // 20 # minimum 5%
killme = []
for key, cell in jitcell_dict.iteritems():
if cell.counter >= 0:
cell.counter = int(cell.counter * 0.92)
if cell.counter < minimum:
killme.append(key)
elif (cell.counter == -1
and cell.get_procedure_token() is None):
killme.append(key)
for key in killme:
del jitcell_dict[key]
#
def _maybe_cleanup_dict():
# Once in a while, rarely, when too many entries have
# been put in the jitdict_dict, we do a cleanup phase:
# we decay all counters and kill entries with a too
# low counter.
self._trigger_automatic_cleanup += 1
if self._trigger_automatic_cleanup > 20000:
self._trigger_automatic_cleanup = 0
_cleanup_dict()
#
self._trigger_automatic_cleanup = 0
self._jitcell_dict = jitcell_dict # for tests
#
def get_jitcell(build, *greenargs):
try:
cell = jitcell_dict[greenargs]
except KeyError:
if not build:
return None
_maybe_cleanup_dict()
cell = JitCell()
jitcell_dict[greenargs] = cell
return cell
return get_jitcell
def __init__(self, space):
self.space = space
self.content = r_dict(space.eq_w, space.hash_w)
self.info = DictInfo()
self.thing_with_del = OnTheWayOut(self.info)
def new_cache():
return r_dict(sigeq_no_numbering, sighash)
def initialize_as_rdict(self):
assert self.r_dict_content is None
self.r_dict_content = r_dict(self.space.eq_w, self.space.hash_w)
return self.r_dict_content
def sigeq(one, two):
return one.eq(two)
def sigeq_no_numbering(one, two):
""" Cache for iterator numbering should not compare array numbers
"""
return one.eq(two, compare_array_no=False)
def sighash(sig):
return sig.hash()
known_sigs = r_dict(sigeq, sighash)
def find_sig(sig, arr):
sig.invent_array_numbering(arr)
try:
return known_sigs[sig]
except KeyError:
sig.invent_numbering()
known_sigs[sig] = sig
return sig
def _add_ptr_to_cache(ptr, cache):
i = 0
for p in cache:
def make_setdata_from_w_iterable(space, w_iterable=None):
data = r_dict(space.eq_w, space.hash_w)
if w_iterable is not None:
for w_item in space.viewiterable(w_iterable):
data[w_item] = None
return data
def init():
return r_dict(mycmp, myhash)
def ll_set_functions(self, sm_eq, sm_hash):
"NOT_RPYTHON"
key_eq = sm_eq._callable
key_hash = sm_hash._callable
self._dict = objectmodel.r_dict(key_eq, key_hash)
def new_cache():
return r_dict(sigeq_no_numbering, sighash)
def init():
res = r_dict(mycmp, myhash)
res[obj1] = 42
res[obj2] = 43
return res
def __init__(w_self, space, w_otherdict=None):
if w_otherdict is None:
w_self.content = r_dict(space.eq_w, space.hash_w)
else:
w_self.content = w_otherdict.content.copy()
def init():
return r_dict(space.mycmp, space.myhash)
