diff options
Diffstat (limited to 'Lib/importlib/test/benchmark.py')
| -rw-r--r-- | Lib/importlib/test/benchmark.py | 184 |
1 files changed, 137 insertions, 47 deletions
diff --git a/Lib/importlib/test/benchmark.py b/Lib/importlib/test/benchmark.py index f709a3cce91..b5de6c6b010 100644 --- a/Lib/importlib/test/benchmark.py +++ b/Lib/importlib/test/benchmark.py @@ -1,69 +1,159 @@ +"""Benchmark some basic import use-cases. + +The assumption is made that this benchmark is run in a fresh interpreter and +thus has no external changes made to import-related attributes in sys. + +""" from . import util from .source import util as source_util -import gc import decimal import imp import importlib +import os +import py_compile import sys import timeit -def bench_cache(import_, repeat, number): - """Measure the time it takes to pull from sys.modules.""" +def bench(name, cleanup=lambda: None, *, seconds=1, repeat=3): + """Bench the given statement as many times as necessary until total + executions take one second.""" + stmt = "__import__({!r})".format(name) + timer = timeit.Timer(stmt) + for x in range(repeat): + total_time = 0 + count = 0 + while total_time < seconds: + try: + total_time += timer.timeit(1) + finally: + cleanup() + count += 1 + else: + # One execution too far + if total_time > seconds: + count -= 1 + yield count // seconds + +def from_cache(seconds, repeat): + """sys.modules""" name = '<benchmark import>' + module = imp.new_module(name) + module.__file__ = '<test>' + module.__package__ = '' with util.uncache(name): - module = imp.new_module(name) sys.modules[name] = module - runs = [] - for x in range(repeat): - start_time = timeit.default_timer() - for y in range(number): - import_(name) - end_time = timeit.default_timer() - runs.append(end_time - start_time) - return min(runs) + for result in bench(name, repeat=repeat, seconds=seconds): + yield result -def bench_importing_source(import_, repeat, number, loc=100000): - """Measure importing source from disk. +def builtin_mod(seconds, repeat): + """Built-in module""" + name = 'errno' + if name in sys.modules: + del sys.modules[name] + # Relying on built-in importer being implicit. + for result in bench(name, lambda: sys.modules.pop(name), repeat=repeat, + seconds=seconds): + yield result - For worst-case scenario, the line endings are \\r\\n and thus require - universal newline translation. - """ - name = '__benchmark' - with source_util.create_modules(name) as mapping: - with open(mapping[name], 'w') as file: - for x in range(loc): - file.write("{0}\r\n".format(x)) - with util.import_state(path=[mapping['.root']]): - runs = [] - for x in range(repeat): - start_time = timeit.default_timer() - for y in range(number): - try: - import_(name) - finally: - del sys.modules[name] - end_time = timeit.default_timer() - runs.append(end_time - start_time) - return min(runs) +def source_wo_bytecode(seconds, repeat): + """Source w/o bytecode: simple""" + sys.dont_write_bytecode = True + try: + name = '__importlib_test_benchmark__' + # Clears out sys.modules and puts an entry at the front of sys.path. + with source_util.create_modules(name) as mapping: + assert not os.path.exists(imp.cache_from_source(mapping[name])) + for result in bench(name, lambda: sys.modules.pop(name), repeat=repeat, + seconds=seconds): + yield result + finally: + sys.dont_write_bytecode = False -def main(import_): - args = [('sys.modules', bench_cache, 5, 500000), - ('source', bench_importing_source, 5, 10000)] - test_msg = "{test}, {number} times (best of {repeat}):" - result_msg = "{result:.2f} secs" - gc.disable() +def decimal_wo_bytecode(seconds, repeat): + """Source w/o bytecode: decimal""" + name = 'decimal' + decimal_bytecode = imp.cache_from_source(decimal.__file__) + if os.path.exists(decimal_bytecode): + os.unlink(decimal_bytecode) + sys.dont_write_bytecode = True try: - for name, meth, repeat, number in args: - result = meth(import_, repeat, number) - print(test_msg.format(test=name, repeat=repeat, - number=number).ljust(40), - result_msg.format(result=result).rjust(10)) + for result in bench(name, lambda: sys.modules.pop(name), repeat=repeat, + seconds=seconds): + yield result finally: - gc.enable() + sys.dont_write_bytecode = False + + +def source_writing_bytecode(seconds, repeat): + """Source writing bytecode: simple""" + assert not sys.dont_write_bytecode + name = '__importlib_test_benchmark__' + with source_util.create_modules(name) as mapping: + def cleanup(): + sys.modules.pop(name) + os.unlink(imp.cache_from_source(mapping[name])) + for result in bench(name, cleanup, repeat=repeat, seconds=seconds): + assert not os.path.exists(imp.cache_from_source(mapping[name])) + yield result + + +def decimal_writing_bytecode(seconds, repeat): + """Source writing bytecode: decimal""" + assert not sys.dont_write_bytecode + name = 'decimal' + def cleanup(): + sys.modules.pop(name) + os.unlink(imp.cache_from_source(decimal.__file__)) + for result in bench(name, cleanup, repeat=repeat, seconds=seconds): + yield result + + +def source_using_bytecode(seconds, repeat): + """Bytecode w/ source: simple""" + name = '__importlib_test_benchmark__' + with source_util.create_modules(name) as mapping: + py_compile.compile(mapping[name]) + assert os.path.exists(imp.cache_from_source(mapping[name])) + for result in bench(name, lambda: sys.modules.pop(name), repeat=repeat, + seconds=seconds): + yield result + + +def decimal_using_bytecode(seconds, repeat): + """Bytecode w/ source: decimal""" + name = 'decimal' + py_compile.compile(decimal.__file__) + for result in bench(name, lambda: sys.modules.pop(name), repeat=repeat, + seconds=seconds): + yield result + + +def main(import_): + __builtins__.__import__ = import_ + benchmarks = (from_cache, builtin_mod, + source_using_bytecode, source_wo_bytecode, + source_writing_bytecode, + decimal_using_bytecode, decimal_writing_bytecode, + decimal_wo_bytecode,) + seconds = 1 + seconds_plural = 's' if seconds > 1 else '' + repeat = 3 + header = "Measuring imports/second over {} second{}, best out of {}\n" + print(header.format(seconds, seconds_plural, repeat)) + for benchmark in benchmarks: + print(benchmark.__doc__, "[", end=' ') + sys.stdout.flush() + results = [] + for result in benchmark(seconds=seconds, repeat=repeat): + results.append(result) + print(result, end=' ') + sys.stdout.flush() + assert not sys.dont_write_bytecode + print("]", "best is", format(max(results), ',d')) if __name__ == '__main__': @@ -74,7 +164,7 @@ if __name__ == '__main__': default=False, help="use the built-in __import__") options, args = parser.parse_args() if args: - raise RuntimeError("unrecognized args: {0}".format(args)) + raise RuntimeError("unrecognized args: {}".format(args)) import_ = __import__ if not options.builtin: import_ = importlib.__import__ |