| """Early Recomputation Measurements |
| """ |
|
|
| import functools as ft |
| import multiprocessing.pool |
| import shutil |
| import threading |
| import time |
|
|
| import diskcache as dc |
|
|
|
|
| def make_timer(times): |
| """Make a decorator which accumulates (start, end) in `times` for function |
| calls. |
| |
| """ |
| lock = threading.Lock() |
|
|
| def timer(func): |
| @ft.wraps(func) |
| def wrapper(*args, **kwargs): |
| start = time.time() |
| func(*args, **kwargs) |
| pair = start, time.time() |
| with lock: |
| times.append(pair) |
|
|
| return wrapper |
|
|
| return timer |
|
|
|
|
| def make_worker(times, delay=0.2): |
| """Make a worker which accumulates (start, end) in `times` and sleeps for |
| `delay` seconds. |
| |
| """ |
|
|
| @make_timer(times) |
| def worker(): |
| time.sleep(delay) |
|
|
| return worker |
|
|
|
|
| def make_repeater(func, total=10, delay=0.01): |
| """Make a repeater which calls `func` and sleeps for `delay` seconds |
| repeatedly until `total` seconds have elapsed. |
| |
| """ |
|
|
| def repeat(num): |
| start = time.time() |
| while time.time() - start < total: |
| func() |
| time.sleep(delay) |
|
|
| return repeat |
|
|
|
|
| def frange(start, stop, step=1e-3): |
| """Generator for floating point values from `start` to `stop` by `step`.""" |
| while start < stop: |
| yield start |
| start += step |
|
|
|
|
| def plot(option, filename, cache_times, worker_times): |
| """Plot concurrent workers and latency.""" |
| import matplotlib.pyplot as plt |
|
|
| fig, (workers, latency) = plt.subplots(2, sharex=True) |
|
|
| fig.suptitle(option) |
|
|
| changes = [(start, 1) for start, _ in worker_times] |
| changes.extend((stop, -1) for _, stop in worker_times) |
| changes.sort() |
| start = (changes[0][0] - 1e-6, 0) |
| counts = [start] |
|
|
| for mark, diff in changes: |
| |
| |
|
|
| for step in frange(counts[-1][0], mark): |
| pair = (step, counts[-1][1]) |
| counts.append(pair) |
|
|
| pair = (mark, counts[-1][1] + diff) |
| counts.append(pair) |
|
|
| min_x = min(start for start, _ in cache_times) |
| max_x = max(start for start, _ in cache_times) |
| for step in frange(counts[-1][0], max_x): |
| pair = (step, counts[-1][1]) |
| counts.append(pair) |
|
|
| x_counts = [x - min_x for x, y in counts] |
| y_counts = [y for x, y in counts] |
|
|
| workers.set_title('Concurrency') |
| workers.set_ylabel('Workers') |
| workers.set_ylim(0, 11) |
| workers.plot(x_counts, y_counts) |
|
|
| latency.set_title('Latency') |
| latency.set_ylabel('Seconds') |
| latency.set_ylim(0, 0.5) |
| latency.set_xlabel('Time') |
| x_latency = [start - min_x for start, _ in cache_times] |
| y_latency = [stop - start for start, stop in cache_times] |
| latency.scatter(x_latency, y_latency) |
|
|
| plt.savefig(filename) |
|
|
|
|
| def main(): |
| shutil.rmtree('/tmp/cache') |
| cache = dc.Cache('/tmp/cache') |
|
|
| count = 10 |
|
|
| cache_times = [] |
| timer = make_timer(cache_times) |
|
|
| options = { |
| ('No Caching', 'no-caching.png'): [ |
| timer, |
| ], |
| ('Traditional Caching', 'traditional-caching.png'): [ |
| timer, |
| cache.memoize(expire=1), |
| ], |
| ('Synchronized Locking', 'synchronized-locking.png'): [ |
| timer, |
| cache.memoize(expire=0), |
| dc.barrier(cache, dc.Lock), |
| cache.memoize(expire=1), |
| ], |
| ('Early Recomputation', 'early-recomputation.png'): [ |
| timer, |
| dc.memoize_stampede(cache, expire=1), |
| ], |
| ('Early Recomputation (beta=0.5)', 'early-recomputation-05.png'): [ |
| timer, |
| dc.memoize_stampede(cache, expire=1, beta=0.5), |
| ], |
| ('Early Recomputation (beta=0.3)', 'early-recomputation-03.png'): [ |
| timer, |
| dc.memoize_stampede(cache, expire=1, beta=0.3), |
| ], |
| } |
|
|
| for (option, filename), decorators in options.items(): |
| print('Simulating:', option) |
| worker_times = [] |
| worker = make_worker(worker_times) |
| for decorator in reversed(decorators): |
| worker = decorator(worker) |
|
|
| worker() |
| repeater = make_repeater(worker) |
|
|
| with multiprocessing.pool.ThreadPool(count) as pool: |
| pool.map(repeater, [worker] * count) |
|
|
| plot(option, filename, cache_times, worker_times) |
|
|
| cache.clear() |
| cache_times.clear() |
|
|
|
|
| if __name__ == '__main__': |
| main() |
|
|
