"""Проверка, потом действие: ленивый кеш из нескольких потоков.

    if key not in cache:
        cache[key] = make(key)
    return cache[key]

Четыре потока проходят одни и те же 5000 ключей с общего старта. Печатаются
два отдельных показателя:

  - extra make() calls — лишних вызовов make: сколько раз значение для ключа
    строилось сверх одного раза на ключ;
  - keys split — ключей с расколом: для скольких ключей потоки получили
    РАЗНЫЕ объекты.

Первое не определяет второе: лишнее построение, результат которого выброшен
(так делает setdefault), раскола не даёт.

КАК СЧИТАЕТСЯ РАСКОЛ. Каждый поток сохраняет в seen[i][k] сам полученный
объект, а не его id(), и все ссылки живут до конца опыта; id сравниваются
только после join всех потоков. Сохранять одно число id нельзя: id уникален
лишь на время жизни объекта (library/functions.html#id), объект, вытесненный
из кеша чужой записью, умирает, и его адрес может достаться следующему
объекту. Тогда два разных объекта с непересекающимися временами жизни
выглядят в seen одним, и раскол недосчитывается. Удерживая объекты, мы
сравниваем только одновременно живые — у них id заведомо различны.

Второе опаснее первого: если в кеше лежат блокировки «по ключу», раскол
значит, что два потока держат разные блокировки одного ключа, то есть
взаимного исключения нет вовсе.

`work` — сколько итераций пустого цикла делает make, то есть ширина окна между
проверкой и записью. Блок 2 — два исправления на самом широком окне.
"""
import threading

from common import RUNS, THREADS, env_line, fmt_int, header, run_threads

KEYS = 5_000


def spin(work):
    s = 0
    for i in range(work):
        s += i
    return s


def trial(work, mode):
    cache = {}
    made = []  # list.append атомарен в обеих сборках (library/threadsafety)
    lock = threading.Lock()
    seen = [dict() for _ in range(THREADS)]

    def make(k):
        spin(work)
        made.append(k)
        return object()

    def naive(i):
        for k in range(KEYS):
            if k not in cache:
                cache[k] = make(k)
            seen[i][k] = cache[k]  # сам объект, не id: см. шапку

    def with_setdefault(i):
        for k in range(KEYS):
            v = cache.get(k)
            if v is None:
                v = cache.setdefault(k, make(k))
            seen[i][k] = v

    def with_lock(i):
        for k in range(KEYS):
            v = cache.get(k)
            if v is None:
                with lock:
                    v = cache.get(k)
                    if v is None:
                        v = cache[k] = make(k)
            seen[i][k] = v

    target = {"naive": naive, "setdefault": with_setdefault, "lock": with_lock}[mode]
    run_threads(target, args_for=lambda i: (i,))
    # Все потоки завершены, а seen по-прежнему держит каждый полученный объект:
    # сравниваются id одновременно живых объектов.
    extra_make_calls = len(made) - KEYS
    split_keys = sum(1 for k in range(KEYS) if len({id(s[k]) for s in seen}) > 1)
    return extra_make_calls, split_keys


def show(label, results):
    extra_make_calls = [e for e, _ in results]
    split_keys = [s for _, s in results]
    print(f"{label:<12} extra make() calls: {extra_make_calls}; keys split: {split_keys}")


def main():
    print(env_line())
    print(f"threads {THREADS}, keys {fmt_int(KEYS)}, runs {RUNS}")
    print("keys split: every object a thread got is kept alive until all threads")
    print("have joined, then compared by id()")

    header(1, "NAIVE CACHE: EXTRA BUILDS AND SPLIT KEYS")
    for work in (0, 100, 1000):
        show(f"work={work}", [trial(work, "naive") for _ in range(RUNS)])

    header(2, "FIXES AT THE WIDEST WINDOW (1000 ITERATIONS)")
    show("setdefault", [trial(1000, "setdefault") for _ in range(RUNS)])
    show("lock", [trial(1000, "lock") for _ in range(RUNS)])


if __name__ == "__main__":
    main()