oldformat_u_b = Benchmark(oldformat_u_f, setup=setup_u, description="Old formatting: s1 = '%s%s' % (s1, s2)") def newformat_u_f(instr1, instr2): for x in xrange(10000): leftover = u"{0}{1}".format(instr1, instr2) newformat_u_b = Benchmark( newformat_u_f, setup=setup_u, description="New formatting: s1 = '{0}{1}'.format(s1, s2)") suite_u = Suite([oldformat_u_b, simple_u_b, join_u_b]) def setup_b(): return { 'instr1': string.ascii_lowercase.encode(), 'instr2': string.ascii_uppercase.encode(), } def simple_b_f(instr1, instr2): for x in xrange(10000): leftover = instr1 + instr2 simple_b_b = Benchmark(simple_b_f,
s = set() for x in dupset: s.add(x) def inserting_dict_f(): s = list() for x in dupset: s.append(x) def inserting_dict_and_making_set_f(): s = list() for x in dupset: s.append(x) s = set(s) dictset_b = Benchmark(dictset_f, description="dictionary as set") setset_b = Benchmark(setset_f, description="set") listset_b = Benchmark(listset_f, description="list") inserting_set_b = Benchmark(inserting_set_f, description="inserting into set") inserting_dict_b = Benchmark(inserting_dict_f, description="appending into list") inserting_dict_and_making_set_b = Benchmark(inserting_dict_and_making_set_f, description="set(list)") suite = Suite([dictset_b, setset_b, listset_b]) suite2 = Suite( [inserting_set_b, inserting_dict_b, inserting_dict_and_making_set_b])
def test_suite(self): suite = Suite(benchmarks=[Benchmark('10*10', iterations=10000, duration=0.1)]) suite.benchmarks.append(Benchmark('100*100', iterations=10000, duration=0.1)) results = suite.run() self.assertEqual(len(results), 2)
result = result + (x * char) add_two_b_b = Benchmark(add_two_f, setup=setup_b, description="Simple byte concatenation: s1 = s1 + s2") add_two_u_b = Benchmark( add_two_f, setup=setup_u, description="Simple unicode concatenation: s1 = s1 + s2") def join_two_f(char, null): l = [] for x in xrange(1000): l.append(x * char) result = null.join(l) join_two_b_b = Benchmark(join_two_f, setup=setup_b, description="Joining a byte list: s1 = ''.join(l)") join_two_u_b = Benchmark(join_two_f, setup=setup_u, description="Joining a unicode list: s1 = ''.join(l)") suite = Suite([add_two_b_b, join_two_b_b, add_two_u_b, join_two_u_b])
def sorted_list_f(l): return sorted(l) cl = lambda a, b: -cmp(a * 2, b * 2) kl = lambda a: a * 2 def sort_cmp(l): l.sort(cmp=cl) def sort_key(l): l.sort(key=kl) sort_b = Benchmark(sort_f, description="sort") sorted_b = Benchmark(sorted_f, description="sorted") suite = Suite([sort_b, sorted_b]) sort_list_b = Benchmark(sort_list_f, description="sort") sorted_list_b = Benchmark(sorted_list_f, description="sorted") suite2 = Suite([sort_list_b, sorted_list_b]) cmp_b = Benchmark(sort_cmp, description="cmp", setup=thesetup) key_b = Benchmark(sort_key, description="key", setup=thesetup) suite3 = Suite([cmp_b, key_b])
s = unull for x in xrange(999, -1, -1): f = thelist[x] s = s + f simple_u_b = Benchmark( simple_u_f, description="Simple unicode concatenation: s1 = s1 + s2") def join_b_f(): thelist = byties s = bnull s = s.join(thelist) join_b_b = Benchmark(join_b_f, description="Joining a byte list: s1 = b''.join(l)") def join_u_f(): thelist = stringies s = unull s = s.join(thelist) join_u_b = Benchmark(join_u_f, description="Joining a unicode list: s1 = u''.join(l)") suite = Suite([simple_b_b, join_b_b, simple_u_b, join_u_b])
keys = list(range(1000)) dupes = random.sample(keys, 500) def defaultdict_f(): d = defaultdict(set) for k in keys: d[k].add(0) for k in dupes: d[k].add(0) def normaldict_f(): d = {} for k in keys: if k in d: d[k].add(0) else: d[k] = set([0]) for k in dupes: if k in d: d[k].add(0) else: d[k] = set([0]) defaultdict_b = Benchmark(defaultdict_f, description="defaultdict") normaldict_b = Benchmark(normaldict_f, description="dict") suite = Suite([defaultdict_b, normaldict_b])
real_constant_outside_b = Benchmark(real_constant_outside_f, description="multiplication outside loop") real_constant_inside_b = Benchmark(real_constant_inside_f, description="multiplication inside loop") real_constant_division_outside_b = Benchmark( real_constant_division_outside_f, description="division outside loop") real_constant_division_inside_b = Benchmark(real_constant_division_inside_f, description="division inside loop") pseudo_constant_outside_b = Benchmark( pseudo_constant_outside_f, description="var multiplication outside loop") pseudo_constant_inside_b = Benchmark( pseudo_constant_inside_f, description="var multiplication inside loop") pseudo_constant_power_outside_b = Benchmark( pseudo_constant_power_outside_f, description="var power outside loop") pseudo_constant_power_inside_b = Benchmark(pseudo_constant_power_inside_f, description="var power inside loop") variation_b = Benchmark(variation_f, description='non-stupid') suite = Suite([ # real_constant_outside_b, # real_constant_inside_b, # real_constant_division_outside_b, real_constant_division_inside_b, pseudo_constant_outside_b, pseudo_constant_inside_b, pseudo_constant_power_outside_b, pseudo_constant_power_inside_b, # variation_b, ])
b = ''.join((strings[999], strings[20], strings[14], strings[200])) join_four_b = Benchmark(join_four_f, description="Joining 4") def add_ten_f(): for x in range(999, -1, -1): b = strings[999] + strings[20] + strings[14] + strings[200] + strings[ 234] + strings[9] + strings[40] + strings[5] + strings[ 120] + strings[123] add_ten_b = Benchmark(add_ten_f, description="Adding 4") def join_ten_f(): l = [] for x in range(999, -1, -1): b = ''.join((strings[999], strings[20], strings[14], strings[200], strings[234], strings[9], strings[40], strings[5], strings[120], strings[123])) join_ten_b = Benchmark(join_ten_f, description="Joining 4") suite = Suite([ add_two_b, join_two_b, add_three_b, join_three_b, add_four_b, join_four_b, add_ten_b, join_ten_b ])