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%}")
