def do_work(info): from automap import FrozenAutoMap namespace = {"FrozenAutoMap": FrozenAutoMap} create_a = Timer("FrozenAutoMap(keys)", globals=namespace) create_d = Timer("{k: i for i, k in enumerate(keys)}", globals=namespace) access_a = Timer("for key in a: a[key]", "a = FrozenAutoMap(keys)", globals=namespace) access_d = Timer( "for key in d: d[key]", "d = {k: i for i, k in enumerate(keys)}", globals=namespace, ) kind, power, factor = info items = factor * 10**power namespace["keys"] = [*{kind(random()) for _ in range(items)}] iterations = max(create_a.autorange()[0], create_d.autorange()[0]) create = create_a.timeit(iterations) / create_d.timeit(iterations) size = getsizeof(FrozenAutoMap(namespace["keys"])) / getsizeof( {k: i for i, k in enumerate(namespace["keys"])}) iterations = max(access_a.autorange()[0], access_d.autorange()[0]) access = access_a.timeit(iterations) / access_d.timeit(iterations) return items, create, access, size
def create_and_store_time_scaling_data(): Record = namedtuple('Record', 'ndim name size fidelity number time_per norm_time_per') records = [] bi_fidelity_functions = [ *mf2.bi_fidelity_functions, *[func(0.5) for func in mf2.adjustable.bi_fidelity_functions] ] for func in bi_fidelity_functions: print(func.name) base_times = {'high': None, 'low': None} for size in [10**i for i in range(7)]: print(size, end=' ', flush=True) for fid in ('high', 'low'): t = Timer( stmt=f'func.{fid}(X)', setup=f'X = np.random.rand({size}, {func.ndim})', globals={'np': np, 'func': func}, ) num, time = t.autorange() time_per = time/num if base_times[fid] is None: base_times[fid] = time_per norm_time_per = 1 else: norm_time_per = (time/num) / base_times[fid] records.append(Record(func.ndim, func.name, size, fid, num, time_per, norm_time_per)) print() return pd.DataFrame.from_records(records, columns=Record._fields)
def timeit_kernel(kernel: str = 'd00', convolution_size: Tuple[int, int] = (64, 64), image_pixel: Tuple[float, float] = (1.0, 1.0), psf_pixel: Tuple[float, float] = (1.0, 1.0), psf_size: Tuple[int, int] = (25, 25), n_sources: int = 6000, sigma: float = 2.0, timeout: float = 5.0): pos = make_random_positions(n_sources, convolution_size) psf = make_gaussian_psf_lut(psf_size, sigma) convolution = ConvolveLibrary(kernel, convolution_size, image_pixel, psf_pixel, debug=False) convolution.positions = pos convolution.psf = psf convolution.launch() t = Timer("convolution.launch()", globals={'convolution': convolution}) number, elapsed_time = t.autorange() repeat = int(timeout / elapsed_time) if repeat < 1: results = np.asarray([elapsed_time]) / number else: results = np.asarray(t.repeat(repeat=repeat, number=number)) / number return TimeitProfile(mean=float(np.mean(results)), std=float(np.std(results)), repeat=results.size, number=number)
def run_timeit(function): timer = Timer(function) iterations, _ = timer.autorange() raw_timings = timer.repeat(3, iterations) per_iteration_timings_ns = [dt / iterations for dt in raw_timings] best_ns = min(per_iteration_timings_ns) return best_ns * NS_PER_SEC
def run_timeit(function, title, baseline=None): timer = Timer(function) iterations, _ = timer.autorange() raw_timings = timer.repeat(3, iterations) per_iteration_timings_ns = [dt / iterations for dt in raw_timings] best_ns = min(per_iteration_timings_ns) result = best_ns * NS_PER_SEC speedup_str = "" if baseline: speedup_str = f" {baseline/result:,.2f} X Speedup" print(f"{title}\t{result:,.2f}ns{speedup_str}") return result
def min_time(algorithm: str, n: int) -> float: timer = Timer(f's({n})', f'from {algorithm} import s') number, t = timer.autorange() repeat = 5 if t < 5 else 1 raw_timings = timer.repeat(repeat, number) return min(dt / number for dt in raw_timings)
def main(args=None, *, _wrap_timer=None): """ Main program, used when run as a script. The optional 'args' argument specifies the command line to be parsed, defaulting to sys.argv[1:]. The return value is an exit code to be passed to sys.exit(); it may be None to indicate success. When an exception happens during timing, a traceback is printed to stderr and the return value is 1. Exceptions at other times (including the template compilation) are not caught. '_wrap_timer' is an internal interface used for unit testing. If it is not None, it must be a callable that accepts a timer function and returns another timer function (used for unit testing). """ if args is None: args = sys.argv[1:] import getopt try: opts, args = getopt.getopt(args, "n:u:s:r:tcpvh", [ "number=", "setup=", "repeat=", "time", "clock", "process", "verbose", "unit=", "help" ]) except getopt.error as err: print(err) print("use -h/--help for command line help") return 2 timer = default_timer stmt = "\n".join(args) or "pass" number = 0 # auto-determine setup = [] repeat = default_repeat verbose = 0 time_unit = None units = {"nsec": 1e-9, "usec": 1e-6, "msec": 1e-3, "sec": 1.0} precision = 3 for o, a in opts: if o in ("-n", "--number"): number = int(a) if o in ("-s", "--setup"): setup.append(a) if o in ("-u", "--unit"): if a in units: time_unit = a else: print( "Unrecognized unit. Please select nsec, usec, msec, or sec.", file=sys.stderr) return 2 if o in ("-r", "--repeat"): repeat = int(a) if repeat <= 0: repeat = 1 if o in ("-p", "--process"): timer = time.process_time if o in ("-v", "--verbose"): if verbose: precision += 1 verbose += 1 if o in ("-h", "--help"): print(__doc__, end=' ') return 0 setup = "\n".join(setup) or "pass" # Include the current directory, so that local imports work (sys.path # contains the directory of this script, rather than the current # directory) import os sys.path.insert(0, os.curdir) if _wrap_timer is not None: timer = _wrap_timer(timer) t = Timer(stmt, setup, timer) if number == 0: # determine number so that 0.2 <= total time < 2.0 callback = None if verbose: def callback(number, time_taken): msg = "{num} loop{s} -> {secs:.{prec}g} secs" plural = (number != 1) print( msg.format(num=number, s='s' if plural else '', secs=time_taken, prec=precision)) try: number, _ = t.autorange(callback) except: t.print_exc() return 1 if verbose: print() try: raw_timings = t.repeat(repeat, number) except: t.print_exc() return 1 def format_time(dt): unit = time_unit scale: float = 1.0 if unit is not None: scale = units[unit] else: scales = [(scale, unit) for unit, scale in units.items()] scales.sort(reverse=True) for scale, unit in scales: if dt >= scale: break return "%.*g %s" % (precision, dt / scale, unit) if verbose: print("raw times: %s" % ", ".join(map(format_time, raw_timings))) print() timings = [dt / number for dt in raw_timings] best = min(timings) print("%d loop%s, best of %d: %s per loop" % (number, 's' if number != 1 else '', repeat, format_time(best))) best = min(timings) worst = max(timings) if worst >= best * 4: import warnings warnings.warn_explicit( "The test results are likely unreliable. " "The worst time (%s) was more than four times " "slower than the best time (%s)." % (format_time(worst), format_time(best)), UserWarning, '', 0) return None
from automap import FrozenAutoMap namespace = {"FrozenAutoMap": FrozenAutoMap} create_a = Timer("FrozenAutoMap(keys)", globals=namespace) create_d = Timer("{k: i for i, k in enumerate(keys)}", globals=namespace) access_a = Timer("for key in a: a[key]", "a = FrozenAutoMap(keys)", globals=namespace) access_d = Timer("for key in d: d[key]", "d = {k: i for i, k in enumerate(keys)}", globals=namespace) print("ITEMS\tCREATE\tACCESS\tSIZE") for power in range(0, 6): for factor in range(1, 10): items = factor * 10**power namespace["keys"] = [*{str(random()) for _ in range(items)}] iterations = max(create_a.autorange()[0], create_d.autorange()[0]) create = create_a.timeit(iterations) / create_d.timeit(iterations) - 1 size = (getsizeof(FrozenAutoMap(namespace["keys"])) / getsizeof({k: i for i, k in enumerate(namespace["keys"])}) - 1) iterations = max(access_a.autorange()[0], access_d.autorange()[0]) access = access_a.timeit(iterations) / access_d.timeit(iterations) - 1 print(f"{items:,}\t{create:+.0%}\t{access:+.0%}\t{size:+.0%}")