|
|
"""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() |
|
|
|
