def run_benchmark(
benchmark_module, module, function, setup_suffix='', repeat=1000):
setup_func = 'setup_' + function
if setup_suffix:
print('%s with %s:' % (function, setup_suffix), end='')
setup_func += '_' + setup_suffix
else:
print('%s:' % function, end='')
results = timeit.repeat(
'%s(*args)' % function,
setup=(SETUP_CODE % {
'benchmark_module': benchmark_module, 'setup_function': setup_func,
'module': module, 'function': function}),
repeat=repeat, number=1)
print('\tavg=%dus' % (sum(results) / len(results) * 1000000.),
'\tmin=%dus' % (min(results) * 1000000.))
python类repeat()的实例源码
def print_timing(self):
# pylint: disable=no-self-use
# Test the implementation of asttokens.util.walk, which uses the same approach as
# visit_tree(). This doesn't run as a normal unittest, but if you'd like to see timings, e.g.
# after experimenting with the implementation, run this to see them:
#
# nosetests -i print_timing -s tests.test_util
#
import timeit
import textwrap
setup = textwrap.dedent(
'''
import ast, asttokens
source = "foo(bar(1 + 2), 'hello' + ', ' + 'world')"
atok = asttokens.ASTTokens(source, parse=True)
''')
print("ast", sorted(timeit.repeat(
setup=setup, number=10000,
stmt='len(list(ast.walk(atok.tree)))')))
print("util", sorted(timeit.repeat(
setup=setup, number=10000,
stmt='len(list(asttokens.util.walk(atok.tree)))')))
def print_timing(self):
# Print the timing of mark_tokens(). This doesn't normally run as a unittest, but if you'd like
# to see timings, e.g. while optimizing the implementation, run this to see them:
#
# nosetests -m print_timing -s tests.test_mark_tokens tests.test_astroid
#
# pylint: disable=no-self-use
import timeit
print("mark_tokens", sorted(timeit.repeat(
setup=textwrap.dedent(
'''
import ast, asttokens
source = "foo(bar(1 + 2), 'hello' + ', ' + 'world')"
atok = asttokens.ASTTokens(source)
tree = ast.parse(source)
'''),
stmt='atok.mark_tokens(tree)',
repeat=3,
number=1000)))
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def timer(fn):
"""
Create a timeit call to a function and pass in keyword arguments.
The function is called twice, once using the standard workbook, then with the optimised one.
Time from the best of three is taken.
"""
print("lxml", openpyxl.LXML)
result = []
for opt in (False, True,):
print("Workbook is {0}".format(opt and "optimised" or "not optimised"))
times = timeit.repeat("{0}({1})".format(fn.__name__, opt),
setup="from __main__ import {0}".format(fn.__name__),
number = 1,
repeat = 3
)
print("{0:.2f}s".format(min(times)))
result.append(min(times))
std, opt = result
print("Optimised takes {0:.2%} time\n".format(opt/std))
return std, opt
def repeat(self, stmt, setup, repeat=None, number=None):
self.fake_timer = FakeTimer()
t = timeit.Timer(stmt=stmt, setup=setup, timer=self.fake_timer)
kwargs = {}
if repeat is None:
repeat = DEFAULT_REPEAT
else:
kwargs['repeat'] = repeat
if number is None:
number = DEFAULT_NUMBER
else:
kwargs['number'] = number
delta_times = t.repeat(**kwargs)
self.assertEqual(self.fake_timer.setup_calls, repeat)
self.assertEqual(self.fake_timer.count, repeat * number)
self.assertEqual(delta_times, repeat * [float(number)])
# Takes too long to run in debug build.
#def test_repeat_default(self):
# self.repeat(self.fake_stmt, self.fake_setup)
def test_speed_np_builtins(size, nLoop, nRep=1):
setupCode = (
"import numpy as np;" +
"PRNG = np.random.RandomState(0);" +
"x = PRNG.rand(%d);" % (size)
)
pprint_timeit(
stmt='np.argmax(x)',
setup=setupCode, number=nLoop, repeat=nRep)
pprint_timeit(
stmt='np.argsort(x)',
setup=setupCode, number=nLoop, repeat=nRep)
nnzPerRows = [0]
for expval in np.arange(0, np.ceil(np.log2(size / 2))):
nnzPerRows.append(2**expval)
for nnzPerRow in nnzPerRows:
funcCode = 'np.argpartition(x, %d)' % (nnzPerRow)
pprint_timeit(
stmt=funcCode, setup=setupCode, number=nLoop, repeat=nRep)
def check(self):
timeme = self.item_options['timeme']
requests = timeme['requests'] if 'requests' in timeme else 5
limit_max = timeme.get('limit_max')
limit_avg = timeme.get('limit_avg')
from requests import Session
s = Session()
request = URLUtils.prepare_request(self.url, self.global_options, self.item_options)
times = timeit.repeat(stmt=lambda:s.send(request, timeout=30, allow_redirects=True),
repeat=requests, number=1)
request_max = max(times)
request_avg = reduce(lambda x, y: x + y, times) / len(times)
if limit_max and request_max > limit_max:
self.fail("Maximum request time greater than limit: {0} > {1}".format(request_max, limit_max))
if limit_avg and request_avg > limit_avg:
self.fail("Average request time greater than limit: {0} > {1}".format(request_avg, limit_avg))
return self.is_ok()
def clock(label, cmd):
res = timeit.repeat(cmd, setup=SETUP, number=TIMES)
print(label, *('{:.3f}'.format(x) for x in res))
def test(container_type, verbose):
MAX_EXPONENT = 7
for n in range(3, MAX_EXPONENT + 1):
size = 10**n
setup = SETUP.format(container_type=container_type,
size=size, verbose=verbose)
test = TEST.format(verbose=verbose)
tt = timeit.repeat(stmt=test, setup=setup, repeat=5, number=1)
print('|{:{}d}|{:f}'.format(size, MAX_EXPONENT + 1, min(tt)))
def do_tests():
for test_key in test_keys:
func_name = 'exists_and_truthy_' + test_key
test = func_name + '(gizmo, "gadget")'
setup = 'from __main__ import gizmo, ' + func_name
elapsed = average(timeit.repeat(test, repeat=5, setup=setup))
print(test_key.rjust(7), format(elapsed, '0.5f'))
def test():
for test_key in test_keys:
test_name = 'test_' + test_key
test = globals()[test_name]
setup = 'from __main__ import gizmo'
t_present = min(timeit.repeat(test, setup=setup))
del gizmo.gadget
t_absent = min(timeit.repeat(test, setup=setup))
gizmo.gadget = True
print('{:7} {:.3f} {:.3f}'.format(test_key, t_present, t_absent))
def run_timeit(quotes, iterations, repeat, jit=False, load=False,
cython=False, profile=False):
quotes_schema = QuoteSchema(many=True)
if jit:
if cython:
quotes_schema.jit = CythonJit
else:
quotes_schema.jit = Jit
if profile:
profile = cProfile.Profile()
profile.enable()
dumped_quotes = quotes_schema.dump(quotes).data
gc.collect()
if load:
def marshmallow_func():
quotes_schema.load(dumped_quotes, many=True)
else:
def marshmallow_func():
quotes_schema.dump(quotes)
best = min(timeit.repeat(marshmallow_func,
'gc.enable()',
number=iterations,
repeat=repeat))
if profile:
profile.disable()
file_name = 'optimized.pprof' if jit else 'original.pprof'
profile.dump_stats(file_name)
usec = best * 1e6 / iterations
return usec
def time(stmt, iterations, setup):
print('Timing: ' + stmt)
times = timeit.repeat(stmt=stmt, number=iterations, setup=setup)
best = min(times)
print('{0} loops, best of 3: {1}'.format(iterations, best))
return best
def bench(name, func):
print('{}: {:.3f} seconds'.format(name, min(timeit.repeat(func, number=1, repeat=3))))
def test_repeat_zero_reps(self):
self.repeat(self.fake_stmt, self.fake_setup, repeat=0)
def test_repeat_zero_iters(self):
self.repeat(self.fake_stmt, self.fake_setup, number=0)
def test_repeat_few_reps_and_iters(self):
self.repeat(self.fake_stmt, self.fake_setup, repeat=3, number=5)
def test_repeat_callable_stmt(self):
self.repeat(self.fake_callable_stmt, self.fake_setup,
repeat=3, number=5)
def test_repeat_function_zero_reps(self):
delta_times = timeit.repeat(self.fake_stmt, self.fake_setup, repeat=0,
timer=FakeTimer())
self.assertEqual(delta_times, [])
def test_repeat_function_zero_iters(self):
delta_times = timeit.repeat(self.fake_stmt, self.fake_setup, number=0,
timer=FakeTimer())
self.assertEqual(delta_times, DEFAULT_REPEAT * [0.0])
def use_fullpage(self, address_space):
"""Calibrate the scanner to ensure fastest speed"""
# Define the calibration functions
timeit_fullpage = lambda: list(self.scan_page(address_space, 0, True))
timeit_nonfullpage = lambda: list(self.scan_page(address_space, 0, False))
with_fullpage = timeit.repeat(timeit_fullpage, number = 100)
without_fullpage = timeit.repeat(timeit_nonfullpage, number = 100)
return min(with_fullpage) < min(without_fullpage)
def test_repeat_zero_reps(self):
self.repeat(self.fake_stmt, self.fake_setup, repeat=0)
def test_repeat_zero_iters(self):
self.repeat(self.fake_stmt, self.fake_setup, number=0)
def test_repeat_few_reps_and_iters(self):
self.repeat(self.fake_stmt, self.fake_setup, repeat=3, number=5)
def test_repeat_callable_stmt(self):
self.repeat(self.fake_callable_stmt, self.fake_setup,
repeat=3, number=5)
