MEASUREMENT

bench/stretched-cache/waitcost.py

The script that produced the numbers in the article, and the record of the run. The file is read from the repository at build time — this is the code that was run, not a copy of it.

Cited in

/en/system-design/caching/stretched-cache

Run on

Redis 7.0.15, PostgreSQL 16.13, Python 3.11.15, redis-py 8.1.0

How to run it

python3 bench/stretched-cache/replication.py   # блоки 1-3
python3 bench/stretched-cache/cluster.py       # блоки 4-6
python3 bench/stretched-cache/latency.py       # блок 7
python3 bench/stretched-cache/readsdown.py     # блок 8
python3 bench/stretched-cache/offsets.py       # блок 9
python3 bench/stretched-cache/waitcost.py      # блок 10
python3 bench/stretched-cache/relaycheck.py    # блоки 11-14
python3 bench/stretched-cache/versions.py      # блок 15

The run below is recorded in Russian. It is a lab record, kept in the language it was written in; the numbers, the tables and the code read the same either way.

Record of the run

Замеры для статьи «Растянутый кэш на два датацентра»

Скрипт	Что делает
`link.py`	канал между датацентрами: ретранслятор в пользовательском коде, который задерживает байты и умеет обрываться. Два варианта: конвейерный `DelayedLink` и сериализующий `SerializingLink` — разница между ними измерена в блоке 13. Общий модуль, сам ничего не печатает
`replication.py`	мастер в одном ДЦ, реплика в другом: отставание, потеря подтверждённых записей при переключении, цена `WAIT` — блоки 1–3
`cluster.py`	кластер из шести узлов, три раскладки по датацентрам, разрыв канала — блоки 4–6
`latency.py`	кэш в чужом ДЦ против базы в своём — блок 7
`readsdown.py`	что решает `cluster-allow-reads-when-down` — блок 8
`offsets.py`	чем измеряется окно потерь: отставание против круга — блок 9
`waitcost.py`	из чего складывается цена `WAIT`, на трёх расстояниях — блок 10
`relaycheck.py`	проверка самого стенда: во что он обходится при нулевой задержке, сколько раз задержка применяется к операции, сериализующий канал против конвейерного, калибровка — блоки 11–14
`versions.py`	те же утверждения на Redis 7.0.15, Redis 8.10.1 и Valkey 9.1.2 — блок 15

python3 bench/stretched-cache/replication.py   # блоки 1-3
python3 bench/stretched-cache/cluster.py       # блоки 4-6
python3 bench/stretched-cache/latency.py       # блок 7
python3 bench/stretched-cache/readsdown.py     # блок 8
python3 bench/stretched-cache/offsets.py       # блок 9
python3 bench/stretched-cache/waitcost.py      # блок 10
python3 bench/stretched-cache/relaycheck.py    # блоки 11-14
python3 bench/stretched-cache/versions.py      # блок 15

Нужен redis-server в PATH, для кластера ещё и redis-cli, для latency.py — работающий PostgreSQL (DSN в DE_TEST_DATABASE_URL). Другую сборку можно подсунуть через REDIS_SERVER_BIN и REDIS_CLI_BIN; versions.py берёт список из DE_REDIS_BUILDS вида «имя=каталог/bin» через запятую. Узлы поднимаются во временных каталогах на случайных портах и убиваются в finally; после себя скрипты не оставляют ни процессов, ни файлов.

Чем изображается разрыв, и почему двумя разными способами

В replication.py, latency.py, offsets.py, waitcost.py и relaycheck.py — ретранслятором link.py. Он слушает порт, соединяется с настоящим Redis и переносит байты, задерживая каждую порцию на заданное время. tc netem был бы честнее, но в ядре этой среды его попросту нет: CONFIG_NET_SCH_NETEM не собран, и tc qdisc add ... netem отвечает Error: Specified qdisc kind is unknown. Права тут ни при чём.

И у этого ретранслятора нашлось два дефекта — оба измерены и устранены. Первый: на его двух соединениях не был выставлен TCP_NODELAY, и пара «алгоритм Нейгла — отложенное подтверждение» добавляла сорок миллисекунд к каждой операции, где по каналу шло несколько мелких сообщений подряд. Ровно эти сорок миллисекунд первая версия статьи опубликовала как «слагаемое неизвестной природы» в цене WAIT. Второй: задержка ставилась между recv и sendall в одном потоке, поэтому порции шли по очереди, а не параллельно, и операция стоила на один лишний перелёт дороже. Пока первый дефект был на месте, второй был невидим — он вчетверо меньше. Подробности печатает relaycheck.py.

У ретранслятора есть cut(): он закрывает все соединения и перестаёт принимать новые. Это важнее задержки. Разрыв между датацентрами — это не «стало медленно», а «перестало ходить вовсе», и изображать его увеличенной задержкой нельзя: репликация с задержкой в десять секунд всё равно догонит, а оборванная — нет.

В cluster.py — сигналом STOP дальней половине. Здесь ретранслятор не годится: узлы кластера общаются друг с другом по шине напрямую, а не через клиентский порт, и ставить ретранслятор пришлось бы на каждую пару. Процесс, остановленный SIGSTOP, жив и держит порт открытым, но не отвечает и не шлёт heartbeat — для оставшейся половины он неотличим от узла за оборванным каналом. Убить узлы было нельзя: вторую половину надо было опросить тоже, и а каждая половина наблюдается на СВОЁМ свежем кластере с той же, заданной руками топологией. Это исправление: раньше обе половины проверялись по очереди на одном кластере, и повышение реплики в первой проверке могло изменить топологию для второй. Две последовательные проверки — не две стороны одного разрыва.

Что здесь важно прочитать правильно

Абсолютные миллисекунды не переносятся никуда — ни на другую машину, ни на другую версию Redis. Содержательны отношение внутри блока, знак разницы и то, какая половина кластера ответила, а какая нет. Двадцать миллисекунд в одну сторону выбраны не «чтобы было хуже», а как обычное расстояние между датацентрами в пределах одной страны.

Номера портов в блоках 4–6 случайны и в каждом прогоне свои. Читаются не они, а роли узлов и столбец состояния. Именно поэтому в блоке 5 стоит проследить пальцем, чья реплика где: в этом весь результат.

Блоки 5 и 6 различаются одной перестановкой реплики. Деление узлов по датацентрам в них одинаковое; меняется только то, чью реплику оставили дома. Разница в исходе — между «отказали обе половины» и «одна работает».

Замер задержки сравнивает самую дешёвую операцию базы. Пять тысяч строк, всё в памяти, чтение по первичному ключу. Из того, что первые две строки блока 7 почти совпали, не следует, что кэш не нужен, — следует только правило: поход в кэш обязан быть дешевле той операции источника, которую он заменяет, на этом расстоянии. Для дорогого агрегата ответ может быть и другим, и здесь он не мерился.

Опубликованная основа — Redis 7.0.15, но она не единственная проверка. Блок 15 (versions.py) прогоняет те же утверждения на Redis 8.10.1 и Valkey 9.1.2: ни одно не разошлось. Числа блоков 1–10 при этом на новые версии не переносятся и не заменяются ими — вопрос блока 15 другой: не разъехалось ли поведение.

Что получилось (Redis 7.0.15, PostgreSQL 16.13, Python 3.11.15, redis-py 8.1.0)

Мастер и реплика, канал 20 мс в одну сторону:

что	значение
реплика в том же ДЦ: запись видна через	1,1 мс
реплика в другом ДЦ: запись видна через	20,1 мс

В этом опыте при низкой нагрузке дополнительная задержка видимости почти совпала с добавленным перелётом в одну сторону. Совпадение не есть закон: обработка, буферизация и нагрузка добавляют своё.

Переключение на реплику, 200 подтверждённых клиенту записей:

когда оборвали	оказалось на реплике	потеряно
сразу после записи	107	93 (46,5 %)
через секунду после записи	200	0

Обе строки — один и тот же опыт с единственной разницей: успела ли репликация догнать до обрыва. Проценты — не свойство Redis; переносится граница: под угрозой то, что не доехало до реплики. Чем эта граница измеряется, см. ниже — здесь первая версия ошибалась.

Цена WAIT 1:

что	значение
обычная запись	0,24 мс
запись с `WAIT 1`	41,73 мс
во сколько раз дороже	×171,6

Это ровно один круг до реплики — разбор на трёх расстояниях ниже. Купленное свойство в любом случае слабее ожидаемого: WAIT сообщает число подтвердивших реплик, но не отменяет запись, если их меньше.

Кластер из шести узлов, разрыв канала между датацентрами:

раскладка	ДЦ-1	ДЦ-2
A: все мастера в ДЦ-1, все реплики в ДЦ-2	работает	`CLUSTERDOWN`
B: узлы поровну, мастера 2 и 1	`CLUSTERDOWN`	`CLUSTERDOWN`
C: то же деление, реплика чужого мастера дома	работает	`CLUSTERDOWN`

Главный результат — строка B. У ДЦ-1 большинство мастеров, и голосов на повышение реплики ему хватает, а кэша всё равно нет: реплика мастера, оставшегося в ДЦ-2, тоже осталась в ДЦ-2, и слоты этого мастера не покрыты никем.

Задержка, медиана из 200 замеров:

откуда читаем	медиана	p95
кэш в своём ДЦ	0,10 мс	0,14 мс
база в своём ДЦ	0,09 мс	0,13 мс
кэш в чужом ДЦ	41,09 мс	41,36 мс

Выводы, которые пришлось исправить

Разборов снаружи было два. Первый указал на три вывода, сделанных из одной точки каждый; второй — на сам измерительный стенд. Все указанные места пришлось не переписать словами, а перемерить, и четыре вывода из пяти оказались неверны.

«Наблюдаемое поведение шире документации» — неверно. Было сказано: раз cluster-require-full-coverage описан через записи, а GET тоже получил CLUSTERDOWN, значит поведение шире написанного. На самом деле за чтения отвечает отдельная описанная настройка cluster-allow-reads-when-down, по умолчанию no. readsdown.py меряет обе: с no двадцать ключей из двадцати получают CLUSTERDOWN; с yes узел отдаёт только ключи своих слотов — четырнадцать из двадцати, — остальные перенаправляет за оборванный канал, а записи отказаны при обоих значениях.

«Под угрозой всё, что записано за последний круг» — неверно. Круг совпал с потерей случайно. offsets.py меняет один только темп записи на том же канале и получает 104, 3 и 0 потерянных записей при отставании 3548, 99 и 0 байт. Мерой служит разница смещений потока репликации, а не круг.

«82 мс — это два круга» — неверно, и заменившее его объяснение тоже. waitcost.py показал, что фиксированным числом кругов цена не описывается, и статья честно написала, что сверх круга остаётся слагаемое в 42–44 мс неизвестной природы. Природа оказалась в приборе: relaycheck.py включает и выключает TCP_NODELAY на ретрансляторе при НУЛЕВОЙ задержке и получает 44,00 и 0,70 мс. После исправления цена WAIT — ровно один круг: 10,90, 41,52 и 81,40 мс при отношении 1,09, 1,04 и 1,02.

«Две половины одного разрыва» — так называть две последовательные проверки было нельзя. После первой проверки топология не обязана вернуться к исходной: реплика могла повыситься, слоты переехать. cluster.py теперь поднимает свежий кластер на каждую сторону и печатает топологию до и после, а также смену ролей.

«Большинство плюс реплика каждого потерянного мастера» — условие неполное. Третья часть — свежесть реплики: отставшая сверх cluster-replica-validity-factor выборы не начнёт. В этих опытах она не мешала, и это теперь напечатано, а не предполагается.

Источники

Redis. Redis replication — https://redis.io/docs/latest/operate/oss_and_stack/management/replication/
Redis. Redis cluster specification — https://redis.io/docs/latest/operate/oss_and_stack/reference/cluster-spec/
Redis. Scale with Redis Cluster (cluster-require-full-coverage) — https://redis.io/docs/latest/operate/oss_and_stack/management/scaling/
Valkey. Replication — https://valkey.io/topics/replication/
Valkey. Cluster specification — https://valkey.io/topics/cluster-spec/
PostgreSQL. High Availability, Load Balancing, and Replication — https://www.postgresql.org/docs/current/high-availability.html
PostgreSQL. Replication configuration parameters — https://www.postgresql.org/docs/current/runtime-config-replication.html
Redis. Active-Active geo-distributed databases — https://redis.io/docs/latest/operate/rs/databases/active-active/
Amazon. Caching challenges and strategies — https://aws.amazon.com/builders-library/caching-challenges-and-strategies/

Script

198 lines

"""Из чего складывается цена WAIT: проверка на трёх расстояниях.

ЗАЧЕМ ЭТОТ ЗАМЕР ПОЯВИЛСЯ. В первой версии статьи стояло объяснение: «82 мс —
это два круга: сама запись и опрос реплики». Число измерено, а объяснение к
нему — нет: из одной точки нельзя сказать, два там круга или полтора, и что
будет на другом расстоянии. Утверждение о механизме, выведенное из одной
точки, — это догадка, даже если она правдоподобна.

ЧТО ДЕЛАЕТ СКРИПТ. Меряет ту же пару команд на трёх расстояниях: 5, 20 и 40 мс
в одну сторону. Если цена WAIT — это фиксированное число кругов, отношение
«цена WAIT / круг» на всех трёх строках будет одним и тем же. Если нет —
объяснение придётся менять.

ЕГО ПЕРЕСНИМАЛИ, И ЭТО ЧАСТЬ РЕЗУЛЬТАТА. Первый прогон дал отношения 5.20,
2.10 и 1.55 — то есть «фиксированное число кругов» не подтвердилось, но и
внятной замены не нашлось: сверх круга оставалось 42-44 мс неизвестного
происхождения. Блок 11 (`relaycheck.py`) выяснил происхождение: у
ретранслятора, изображавшего канал, не был выставлен TCP_NODELAY, и залипание
«алгоритм Нейгла — отложенное подтверждение» добавляло сорок миллисекунд к
каждой операции, где по каналу шло несколько мелких сообщений подряд. После
исправления отношение стало единицей на всех трёх расстояниях.

ЗАПУСК: python3 bench/stretched-cache/waitcost.py
Нужен redis-server в PATH (или в REDIS_SERVER_BIN).
"""

from __future__ import annotations

import os
import socket
import statistics
import subprocess
import sys
import tempfile
import time

sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
from link import DelayedLink  # noqa: E402

import redis  # noqa: E402

# Какой сервер запускать. По умолчанию тот, что в PATH; REDIS_SERVER_BIN и
# REDIS_CLI_BIN позволяют прогнать тот же замер на другой сборке — так снята
# таблица регрессии на Redis 8.10.1 и smoke-прогон на Valkey.
SERVER = os.environ.get("REDIS_SERVER_BIN", "redis-server")
CLI = os.environ.get("REDIS_CLI_BIN", "redis-cli")

DELAYS_MS = (5.0, 20.0, 40.0)
WRITES = 20


def free_port() -> int:
    s = socket.socket()
    s.bind(("127.0.0.1", 0))
    port = s.getsockname()[1]
    s.close()
    return port


def start_redis(port: int, dirname: str) -> subprocess.Popen:
    proc = subprocess.Popen([
        SERVER, "--port", str(port), "--dir", dirname,
        "--save", "", "--appendonly", "no",
        "--logfile", os.path.join(dirname, "redis.log"),
    ])
    deadline = time.time() + 10
    while time.time() < deadline:
        try:
            c = redis.Redis(port=port, socket_timeout=0.5)
            if c.ping():
                c.close()
                return proc
        except Exception:
            time.sleep(0.05)
    raise RuntimeError(f"redis на порту {port} не поднялся")


def wait_sync(client: redis.Redis, timeout: float = 15.0) -> None:
    deadline = time.time() + timeout
    while time.time() < deadline:
        if client.info("replication").get("master_link_status") == "up":
            return
        time.sleep(0.1)
    raise RuntimeError("реплика не синхронизировалась")


def median_ms(f, n: int) -> float:
    samples = []
    for i in range(n):
        t0 = time.perf_counter()
        f(i)
        samples.append((time.perf_counter() - t0) * 1000.0)
    return statistics.median(samples)


def main() -> None:
    tmp_a = tempfile.mkdtemp(prefix="wait-a-")
    tmp_b = tempfile.mkdtemp(prefix="wait-b-")
    port_a, port_b = free_port(), free_port()
    proc_a = proc_b = None
    try:
        proc_a = start_redis(port_a, tmp_a)
        proc_b = start_redis(port_b, tmp_b)
        a = redis.Redis(port=port_a, decode_responses=True)
        b = redis.Redis(port=port_b, decode_responses=True)

        version = a.info("server")["redis_version"]
        print(f"Redis {version} · один хост, два процесса")
        print(f"{WRITES} записей на строку, медиана; клиент ходит к мастеру")
        print("напрямую, задержка стоит только на канале мастер — реплика")
        print()
        print("10. ЦЕНА WAIT РАСТЁТ ВМЕСТЕ С РАССТОЯНИЕМ, И ЭТО ПРОВЕРЯЕТСЯ")
        print("-" * 66)
        print("  в одну сторону    круг    обычная    с WAIT 1    WAIT / круг")

        rows: list[tuple[float, float, float]] = []
        for one_way in DELAYS_MS:
            b.replicaof("no", "one")
            link = DelayedLink(port_a, delay_ms=one_way)
            try:
                b.replicaof("127.0.0.1", link.port)
                wait_sync(b)
                time.sleep(0.5)
                # Прогрев: первая запись после синхронизации несёт лишнее.
                a.set("warm", "1")
                a.wait(1, 5000)

                plain = median_ms(lambda i: a.set(f"p:{i}", i), WRITES)

                def with_wait(i: int) -> None:
                    a.set(f"w:{i}", i)
                    a.wait(1, 5000)

                waited = median_ms(with_wait, WRITES)
            finally:
                link.cut()

            rt = 2 * one_way
            rows.append((one_way, plain, waited))
            print(f"  {one_way:>10.0f} мс {rt:>7.0f} мс {plain:>9.2f} мс "
                  f"{waited:>10.2f} мс {waited / rt:>13.2f}")

        print()
        print("  Последний столбец — то, ради чего замер и поставлен. Если бы")
        print("  цена WAIT была фиксированным числом кругов, он был бы одним и")
        print("  тем же на всех трёх строках. Он и есть один и тот же, и равен")
        print("  единице: WAIT стоит РОВНО ОДИН круг.")
        print()
        print("  Разности между строками говорят то же самое:")
        for (ow1, _, w1), (ow2, _, w2) in zip(rows, rows[1:]):
            d_rt = 2 * (ow2 - ow1)
            d_w = w2 - w1
            print(f"    круг вырос на {d_rt:>5.0f} мс, цена WAIT — на "
                  f"{d_w:>6.2f} мс (в {d_w / d_rt:.2f} раза)")
        print()
        # Остаток, не зависящий от расстояния: цена минус один круг.
        print("  Сверх круга остаётся немного, и это не расстояние, а работа")
        print("  самого Redis:")
        for ow, _, w in rows:
            print(f"    при {ow:>4.0f} мс в одну сторону: {w:>6.2f} - "
                  f"{2 * ow:>3.0f} = {w - 2 * ow:>6.2f} мс сверх круга")
        print()
        print("  ИСТОРИЯ ЭТОГО БЛОКА СТОИТ ТОГО, ЧТОБЫ ЕЁ ЗНАТЬ, потому что")
        print("  ошибались тут дважды и по-разному.")
        print()
        print("  Сначала в статье стояло объяснение «82 мс — это два круга»,")
        print("  выведенное из одной точки. Этот замер его опроверг: на трёх")
        print("  расстояниях отношение к кругу было 5.20, 2.10 и 1.55, то есть")
        print("  никаким фиксированным числом кругов цена не описывалась.")
        print("  Вместо объяснения тогда осталось честное «сверх круга есть")
        print("  слагаемое в 42-44 мс, и чем оно вызвано, замер не")
        print("  устанавливает».")
        print()
        print("  Устанавливает блок 11, и ответ оказался про прибор, а не про")
        print("  Redis: у ретранслятора, изображавшего канал, не был выставлен")
        print("  TCP_NODELAY, и пара «алгоритм Нейгла — отложенное")
        print("  подтверждение» добавляла ровно эти сорок миллисекунд. Флаг")
        print("  выставлен, замер переснят — и картина стала простой: WAIT")
        print("  стоит один круг плюс полторы миллисекунды.")
        print()
        print("  Что переносится: WAIT добавляет к записи круг до реплики,")
        print("  и растёт он с расстоянием один к одному. Что не переносится:")
        print("  конкретные числа. Что стоит унести отдельно: вывод, сделанный")
        print("  на непроверенном стенде, бывает неверен даже когда он")
        print("  осторожен.")
    finally:
        for proc in (proc_a, proc_b):
            if proc is not None:
                proc.terminate()
                try:
                    proc.wait(timeout=5)
                except subprocess.TimeoutExpired:
                    proc.kill()


if __name__ == "__main__":
    main()