def __init__(self, method_id, version):
self.start_line = None
self.method_id = method_id
self.version = version
self.file = None
self.start_addr = None
self.code_size = None
self.method_name = None
self.class_name = None
self._addr2line_tree = bintrees.FastRBTree()
self._bci2line_tree = bintrees.FastRBTree()
def run_tests(names, num_items, num_its):
fn_types = dict([
('btrees', (lambda es: BTrees.OOBTree.OOBTree([(e, 1) for e in es]),
BTrees.OOBTree.OOBTree)),
('blist', (lambda es: blist.sorteddict.fromkeys(es, 1),
blist.sorteddict)),
('bintrees', (lambda es: bintrees.FastRBTree([(e, 1) for e in es]),
bintrees.FastRBTree)),
('dict', (lambda es: dict.fromkeys(es, 1), dict)),
('banyan_red_black_tree', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=int, alg=banyan.RED_BLACK_TREE), None)),
('banyan_splay_tree', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=int, alg=banyan.SPLAY_TREE), None)),
('banyan_sorted_list', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=int, alg=banyan.SORTED_LIST), None)),
('banyan_red_black_tree_gen', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=None, alg=banyan.RED_BLACK_TREE), None)),
('banyan_splay_tree_gen', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=None, alg=banyan.SPLAY_TREE), None)),
('banyan_sorted_list_gen', (lambda es: banyan.SortedDict.fromkeys(
es, 1, key_type=None, alg=banyan.SORTED_LIST), None))
])
t = dict([])
for name in names:
t[name] = _run_test(fn_types[name], int, num_items, num_its)
return t
def _bintrees(es):
t = bintrees.FastRBTree()
for i, e in enumerate(es):
t[e] = None
if i % 1 == 0:
for ee in t:
pass
def _bintrees(es):
t = bintrees.FastRBTree()
for e in es:
t[e] = None
if len(t) > 1:
keys = list(t)
c = min([abs(x - y) for (x, y) in zip_(keys[1:], keys[:-1])])
def run_tests(names, num_items, num_its, type_=int):
fns = dict([
('btrees', lambda: BTrees.OOBTree.OOBTree()),
('blist', lambda: blist.sorteddict()),
('bintrees', lambda: bintrees.FastRBTree()), ('dict', lambda: dict()),
('banyan_red_black_tree',
lambda: banyan.SortedDict(key_type=type_, alg=banyan.RED_BLACK_TREE)),
('banyan_red_black_tree_rank_updator',
lambda: banyan.SortedDict(key_type=type_,
alg=banyan.RED_BLACK_TREE,
updator=banyan.RankUpdator)),
('banyan_red_black_tree_min_max_updator',
lambda: banyan.SortedDict(key_type=type_,
alg=banyan.RED_BLACK_TREE,
updator=banyan.MinMaxUpdator)),
('banyan_splay_tree',
lambda: banyan.SortedDict(key_type=type_, alg=banyan.SPLAY_TREE)),
('banyan_sorted_list',
lambda: banyan.SortedDict(key_type=type_, alg=banyan.SORTED_LIST)),
('banyan_red_black_tree_gen',
lambda: banyan.SortedDict(alg=banyan.RED_BLACK_TREE)),
('banyan_splay_tree_gen',
lambda: banyan.SortedDict(alg=banyan.SPLAY_TREE)),
('banyan_sorted_list_gen',
lambda: banyan.SortedDict(alg=banyan.SORTED_LIST))
])
t = dict([])
for name in names:
t[name] = _run_test(fns[name], type_, num_items, num_its)
return t
def update(self):
"""Read the IP assignment data from AFRINIC, ARIN, APNIC, LACNIC
and RIPE and store it in the store."""
ranges = bintrees.FastRBTree()
# Read all the delegate files
ftp = ftplib.FTP('ftp.ripe.net')
ftp.login()
for registry in ['afrinic', 'arin', 'apnic', 'lacnic', 'ripencc']:
parser = DelegatedParser(ranges)
ftp.retrlines('RETR /pub/stats/%s/delegated-%s-extended-latest' \
% (registry, registry),
parser.got_line)
ftp.quit()
# Convert to list
ranges = list(ranges.values())
# Check for overlaps and emit warnings
count = len(ranges)
ndx = 0
while ndx + 1 < count:
e = ranges[ndx]
n = ranges[ndx + 1]
if n.startaddr <= e.endaddr and e.country != n.country:
print('warning: fixed overlap %s, %s' % (e, n),
file=sys.stderr)
if e.endaddr > n.endaddr:
rest = Entry(IP(n.endaddr.int() + 1), e.endaddr,
e.registry, e.country)
ranges.insert(ndx + 2, rest)
count += 1
e.endaddr = IP(n.startaddr.int() - 1)
ndx += 1
# Merge adjacent ranges with the same country code
count = len(ranges)
ndx = 0
while ndx + 1 < count:
if ranges[ndx + 1].country == ranges[ndx].country:
ranges[ndx].endaddr = ranges[ndx + 1].endaddr
del ranges[ndx + 1]
count -= 1
elif ranges[ndx + 1].startaddr == ranges[ndx].startaddr:
print('warning: found conflict - %s, country %s/%s' \
% (ranges[ndx].startaddr, ranges[ndx].country,
ranges[ndx + 1].country), file=sys.stderr)
del ranges[ndx + 1]
count -= 1
else:
ndx += 1
# Save the data
self.store.save([IPRange(r.startaddr, r.country) for r in ranges])
return len(ranges)
def __init__(self, iterator_with_costs, buf_size=1000):
"""
A tool for quickly finding batches with approximately specified cost.
Used for multi-gpu batch balancing
Credits: Yandex MT team
"""
self.iterator_with_costs = iterator_with_costs
self.current_size, self.max_size = 0, buf_size
self.tree = bintrees.FastRBTree()
def _bintrees(es):
t = bintrees.FastRBTree()
for e in es:
t[e] = None
c = 0
for i in t:
if i == e:
break
c += 1
def getMethod(self, method_id, version):
key = method_id + "#" + version
if key in self._method_dict:
return self._method_dict[key]
if version != "0":
return None
key = method_id + "#1"
if key not in self._method_dict:
return None
candidate_method = self._method_dict[key]
new_method = copy.deepcopy(candidate_method)
new_method.version = "0"
new_method.start_addr = "0"
new_method.code_size = "0"
new_method._addr2line_tree = bintrees.FastRBTree()
self.addMethod(new_method)
return new_method
def run_tests(names, num_items, num_its):
fns = dict([
('bintrees', lambda es: bintrees.FastRBTree([(e, None) for e in es])),
('set', lambda es: set(es)),
('banyan_red_black_tree',
lambda es: banyan.SortedSet(es, alg = banyan.RED_BLACK_TREE)),
('banyan_splay_tree',
lambda es: banyan.SortedSet(es, alg = banyan.SPLAY_TREE)),
('banyan_sorted_list',
lambda es: banyan.SortedSet(es, alg = banyan.SORTED_LIST)),
('banyan_red_black_tree_gen',
lambda es: banyan.SortedSet(es, key_type = int, alg = banyan.RED_BLACK_TREE)),
('banyan_splay_tree_gen',
lambda es: banyan.SortedSet(es, key_type = int, alg = banyan.SPLAY_TREE)),
('banyan_sorted_list_gen',
lambda es: banyan.SortedSet(es, key_type = int, alg = banyan.SORTED_LIST))])
t = dict([])
for name in names:
t[name] = _run_test(fns[name], int, num_items, num_its)
return t
def run_tests(names, num_items, num_its, mini_num_items = 1, type_ = int):
fns = dict([
('btrees', lambda es: BTrees.OOBTree.OOSet(es)),
('btree', lambda es: btree.sorted_btree.bulkload(sorted(es), 128)),
('blist', lambda es: blist.sortedset(es)),
('bintrees', lambda es: bintrees.FastRBTree([(e, None) for e in es])),
('set', lambda es: set(es)),
('banyan_red_black_tree',
lambda es: banyan.SortedSet(es, key_type = type_, alg = banyan.RED_BLACK_TREE)),
('banyan_splay_tree',
lambda es: banyan.SortedSet(es, key_type = type_, alg = banyan.SPLAY_TREE)),
('banyan_sorted_list',
lambda es: banyan.SortedSet(es, key_type = type_, alg = banyan.SORTED_LIST)),
('banyan_red_black_tree_gen',
lambda es: banyan.SortedSet(es, alg = banyan.RED_BLACK_TREE)),
('banyan_splay_tree_gen',
lambda es: banyan.SortedSet(es, alg = banyan.SPLAY_TREE)),
('banyan_sorted_list_gen',
lambda es: banyan.SortedSet(es, alg = banyan.SORTED_LIST))])
t = dict([])
for name in names:
t[name] = _run_test(fns[name], type_, num_items, num_its, mini_num_items)
return t
def run_tests(names, num_items, num_its):
# Tmp Ami - make key-type separate labels below
fns = dict([
('btrees', lambda es: BTrees.OOBTree.OOBTree([(e, 1) for e in es])),
('blist', lambda es: blist.sorteddict([(e, 1) for e in es])),
('bintrees', lambda es: bintrees.FastRBTree([(e, 1) for e in es])),
('set', lambda es: set([(e, 1) for e in es])),
('banyan_red_black_tree', lambda es: banyan.SortedDict(
[(e, 1) for e in es], alg=banyan.RED_BLACK_TREE)),
('banyan_splay_tree', lambda es: banyan.SortedDict(
[(e, 1) for e in es], alg=banyan.SPLAY_TREE)),
('banyan_sorted_list', lambda es: banyan.SortedDict(
[(e, 1) for e in es], alg=banyan.SORTED_LIST)),
('banyan_red_black_tree_gen', lambda es: banyan.SortedDict(
[(e, 1) for e in es], key_type=int, alg=banyan.RED_BLACK_TREE)),
('banyan_splay_tree_gen', lambda es: banyan.SortedDic(
[(e, 1) for e in es], key_type=int, alg=banyan.SPLAY_TREE)),
('banyan_sorted_list_gen', lambda es: banyan.SortedDict(
[(e, 1) for e in es], key_type=int, alg=banyan.SORTED_LIST))
])
t = dict([])
for name in names:
t[name] = _run_test(fns[name], int, num_items, num_its)
return t
def __init__(self, hyperkey):
self.hyperkey = hyperkey
self.alerts = bintrees.FastRBTree()
self.alerts.insert(("test1", "test2"),
1) # replace list by tuple -> no crash
def __iter__(self):
self.tree = bintrees.FastRBTree()
self.coord_costs = []
self.rng = random.Random(42)
return self
def __init__(self, iterator=None, buf_size=1000):
self.iterator = iterator
self.buf_size = buf_size
self.tree = bintrees.FastRBTree()
self.coord_costs = []
self.rng = random.Random(42)
def __init__(self):
LinkedList.__init__(self)
self.lut = bintrees.FastRBTree()
self.stack = LinkedList()
self.indexer = index_rbtree.rbtree.RBTree()
self.index_counter = 0
def _bintrees(es):
t = bintrees.FastRBTree([(e, None) for e in es])
def __init__(self):
self.Orders = bintrees.FastRBTree()
self.totalAmount = 0.0
def _bintrees(es):
t = bintrees.FastRBTree()
for e in es:
t[e] = None
for e in es:
t.remove(e)