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 _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(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 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 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 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 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 oof(): d = r_dict(strange_key_eq, strange_key_hash) d['x'] = 42 return d['x']
def new_ref_dict_2(self): return r_dict(rd_eq, rd_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 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)