Причинность, часы и версии данных
На семинаре разберём часы и причинный порядок событий, модели согласованности, работу с версиями данных и разрешение конфликтов.
Время и часы
Несовершенство физических часов
Мы обращаемся к времени очень часто: нам нужно понимать, какое событие произошло раньше, какая версия объекта является более новой, и в основе многих алгоритмов лежат таймауты.
Часы системного времени (wall clock) дают дату и время, например для журнала событий. Их показания могут скачком измениться при коррекции. Для измерения длительности операции и тайм-аутов используют монотонные часы: их показания не убывают, но отсчёты разных машин напрямую сравнивать нельзя.
Физические часы несовершенны. Часы на разных узлах показывают разное время, а скорость их хода меняется, например, с температурой. Смещение — разница показаний с эталоном в данный момент. Дрейф — относительное отличие скорости хода от эталонной. Его измеряют в ppm (parts per million): 1 ppm соответствует одной микросекунде за секунду. При отклонении скорости не более 40 ppm за год без коррекций накопится до 365 * 24 * 60 * 0.000040 ≈ 21 минуты дополнительного смещения.
Для обычных кварцевых часов характерно отклонение порядка десятков ppm, например 20–50 ppm. Более точные атомные часы настраивают генератор по частоте атомного перехода, например цезия-133. Относительная погрешность 1e-14 соответствует примерно одной секунде за 3 миллиона лет. Атомные часы используют, в частности, на спутниках GPS.
Чтобы удерживать смещение в допустимых границах, часы регулярно синхронизируют. NTP (Network Time Protocol) — протокол синхронизации системных часов по сети. Серверы образуют иерархию: сервер уровня stratum 1 получает время от опорного источника, например GPS-приёмника, остальные синхронизируются с серверами верхних уровней. Узел может сверять несколько источников. По четырём отметкам обмена он оценивает смещение часов и сетевое время туда и обратно.
NTP не обеспечивает идеальной синхронизации: оценка смещения предполагает равные задержки запроса и ответа. Асимметрия вносит ошибку, равную половине разности этих задержек. В зависимости от сети и источников времени ошибка может составлять единицы или десятки миллисекунд и быть больше при сбоях. Универсальной гарантии «не более 100 мс» протокол не даёт.
В распределённой базе Spanner используется сервис времени TrueTime. В описанной в статье инфраструктуре есть серверы времени с GPS-приёмниками и серверы с атомными часами; это источники с разными причинами отказов. Узлы сверяют с ними локальные часы и учитывают неопределённость синхронизации и последующий дрейф.
Вызов TT.now() возвращает интервал [earliest, latest]. TrueTime гарантирует, что действительное время вызова находится внутри этого интервала. В статье 2012 года погрешность ε обычно менялась от 1 до 7 мс. Это половина ширины интервала, а не вся ширина; при сбоях она может вырасти.
Перед подтверждением записи Spanner выполняет commit wait: ждёт, пока TT.now().earliest станет больше выбранной метки фиксации. К моменту ответа эта метка заведомо в прошлом. Если после ответа начать актуальное чтение и выбрать его метку снимка по latest, снимок будет позже метки записи и включит её результат. Реплика должна также располагать данными для этого снимка.
Логические часы Лэмпорта
Для отслеживания причинных связей между событиями введём логическое время. Физические часы для этого не нужны: достаточно знать локальный порядок действий и передачу сообщений.
Рассмотрим последовательные процессы, взаимодействующие сообщениями. Здесь и далее один узел представляет такой процесс. Введём отношение happened before: событие A причинно предшествует событию B (A \to B), если выполняется одно из условий:
AиBпроизошли на одном узле, иAпроизошло раньше;A— отправка сообщения, аB— получение этого сообщения;- существует событие
C, для которогоA \to CиC \to B(транзитивность).
Это отношение задаёт строгий частичный порядок.
Возможна ситуация, когда a и b несравнимы: не выполняется ни a \to b, ни b \to a. Тогда события конкурентны (concurrent): a \parallel b. Это означает отсутствие причинного пути между ними; в физическом времени они не обязаны происходить одновременно.
Именно эту идею использует Leslie Lamport для логических часов (которые позже назовут часы Лэмпорта).
Введем функцию C(a), которая назначает каждому событию a в системе число — логическую метку события. От этой функции мы хотим следующее:
a \to b \implies C(a) < C(b)
То есть, если b логически следует из a, то таймстемп b больше таймстемпа a.
Для определения такой функции на каждом узле будем поддерживать числовой счётчик:
- Изначально счётчик на каждом узле равен 0.
- При локальном событии или отправке сообщения счётчик увеличивается на 1. Полученное число становится меткой события; при отправке оно также прикладывается к сообщению.
- При получении сообщения узел
N_1обновляет счётчик по правилуC_{N_1} = \max(C_{N_1}, C(msg)) + 1, гдеC(msg)— метка отправки. Полученное число становится меткой события получения.
Последнее правило гарантирует, что метка получения сообщения больше метки его отправки.
Так один счётчик на узел и метка в каждом сообщении позволяют назначать событиям числа, растущие вдоль причинных связей.
Однако есть существенный недостаток: единственная гарантия, предоставляемая данным порядком, это a \to b \implies C(a) < C(b).
По неравенству C(a) < C(b) нельзя восстановить причинную связь: события могут быть конкурентными. Например, это могут быть локальные события двух узлов, которые не обменивались сообщениями.
Более того, C(a) = C(b) не гарантирует, что a = b. Уникальность событий можно получить, добавив к таймстемпу номер узла, где было создано данное событие: пара (C(e), node_e) уникально идентифицирует событие. Такие пары сравнивают лексикографически: сначала по таймстемпу, а при равенстве — по номеру узла. Полученный полный порядок сохраняет отношение happened before.
Такой порядок полезен, например, для выбора значения в LWW-регистре: реплики выбирают запись с максимальной парой и сходятся к одному результату. Этот пример разберём ниже.
Векторные часы
Расширив идею часов Лэмпорта, можно получить векторные часы, которые предоставляют больше гарантий.
Пусть в системе N узлов с уникальными идентификаторами. Каждый хранит вектор V из N счётчиков. Компонента V[i] показывает, сколько первых событий узла i известно текущему узлу.
- Изначально все компоненты равны 0.
- При локальном событии или отправке сообщения узел
iувеличиваетV[i]на 1. Полученный вектор становится меткой события; к сообщению прикладывается его копия. - При получении сообщения
mузелQберёт покомпонентный максимум:V_Q[i] = \max(V_Q[i], m.V[i])для всехi. Затем увеличивает собственную компоненту:V_Q[Q] = V_Q[Q] + 1. Полученный вектор становится меткой получения.
Как можно заметить, логика обновления счетчиков очень похожа на логику обновления в часах Лэмпорта.
Сравнение векторов происходит покомпонентно:
V_a = V_b \iff V_a[i] = V_b[i] \ \ \forall i \in \{1, 2, \dots, N\}V_a \leqslant V_b \iff V_a[i] \leqslant V_b[i] \ \ \forall i \in \{1, 2, \dots, N\}V_a < V_b \iff V_a \leqslant V_b \land V_a \neq V_bV_a \parallel V_b \iff V_a \not \leqslant V_b \land V_b \not \leqslant V_a
Для меток событий одного исполнения по этим правилам выполняются свойства:
V(a) < V(b) \iff a \to bV(a) = V(b) \iff a = bV(a) \parallel V(b) \iff a \parallel b
Таким образом, V(a) < V(b) означает именно причинное предшествование. Например, метки событий в распределённом журнале позволяют отличить цепочку сообщений, приведшую к ошибке, от независимых событий на других узлах. Для такого анализа нужно учитывать все существенные каналы взаимодействия.
Недостатком векторных часов является их размер. Вместе с сообщением теперь необходимо "таскать" вектор, размер которого линейно зависит от числа участников в системе. Если в системе тысячи узлов, а типичное сообщение имеет размер 100 байт, мы существенно увеличим накладные расходы. Для экономии места можно хранить только ненулевые компоненты в словаре, считая отсутствующие равными нулю. Простое обнуление ненулевых счётчиков нарушает правила часов и может привести к совпадению меток разных событий или неверному причинному порядку. Безопасный сброс требует отдельного протокола, который определяет, как обращаться со старыми метками и сообщениями в пути.
Версии данных и контекст в Dynamo
Идею векторных часов можно применить к обновлениям одного объекта: каждой версии сопоставляется вектор версий (version vector). Компонента со значением n представляет первые n обновлений соответствующего участника: история в каждой компоненте должна быть непрерывным префиксом. Сравнение остаётся покомпонентным:
- одинаковые векторы обозначают одну версию;
- если
V_1 < V_2, вторая версия продолжает первую, поэтому первую можно отбросить; - если векторы несравнимы, версии конкурентны: ни одна не учитывает все изменения другой. Такие версии называют siblings, и пока нужно сохранить обе.
Векторы позволяют обнаружить конфликт, но не определяют, как объединить значения. Например, для двух независимо изменённых корзин покупок это должно решить приложение.
Рассмотрим Amazon Dynamo из статьи 2007 года, секции 4.1 и 4.4. Здесь участники вектора — серверы, координирующие записи данного объекта. Интерфейс явно передаёт контекст:
get(key)возвращает одно или несколько значений вместе сcontext— метаданными об их версиях;put(key, context, value)передаёт новое значение и контекст предыдущего чтения. Сервер использует его, чтобы определить, какие версии эта запись заменяет, и увеличивает свою компоненту вектора.
Контекст означает: «я сделал это обновление на основании вот этих версий». Клиенту не нужно разбирать метаданные, но нужно передать их обратно при записи.
На иллюстрации получается следующая история одного объекта; отсутствующие компоненты вектора равны нулю:
| Версия | На основании чего записана | Вектор версий |
|---|---|---|
| D1 | Создание объекта через Sx | {Sx:1} |
| D2 | Обновление D1 через Sx | {Sx:2} |
| D3 | Обновление D2 через Sy | {Sx:2, Sy:1} |
| D4 | Независимое обновление D2 через Sz | {Sx:2, Sz:1} |
| D5 | Объединение D3 и D4 через Sx | {Sx:3, Sy:1, Sz:1} |
D3 и D4 обе заменяют D2, но несравнимы между собой. Когда чтение возвращает обе ветки, контекст объединяет их векторы покомпонентным максимумом: {Sx:2, Sy:1, Sz:1}. Приложение объединяет значения и записывает результат с этим контекстом: получается D5, заменяющая обе ветки.
Если же клиент прочитал только D3, его контекст не содержит D4. Обновление D3 не должно уничтожить независимую ветку D4. Поэтому одного нового значения в запросе на запись недостаточно.
DVV (Dotted Version Vectors)
Теперь два клиента прочитали одну версию с контекстом {A:1} и независимо отправили изменения на один сервер A. Сервер последовательно присвоил записям номера 2 и 3, но второй клиент не видел запись первого. Мы отслеживаем зависимости версий через чтения клиентов; порядок обработки запросов на сервере сам по себе такой зависимости не создаёт.
Если обозначить вторую запись обычным вектором {A:3}, он будет представлять весь префикс {A₁, A₂, A₃}. Это ошибочно включит первую запись в историю второй.
В рассматриваемом протоколе новая версия получает dotted version vector (DVV) в форме DVV = (context, dot). Контекст описывает историю, учтённую клиентом, а dot — одно новое событие, пара (узел, счётчик). Сервер выдаёт новый уникальный номер, даже если клиент принёс старый контекст.
| Запись | Контекст | dot | История версии |
|---|---|---|---|
| Первая | {A:1} |
(A,2) |
{A₁, A₂} |
| Вторая | {A:1} |
(A,3) |
{A₁, A₃} |
Метка dot позволяет представить пропуск: наличие A₃ не означает, что клиент видел A₂. Эти версии конкурентны, и нужно сохранить обе.
Здесь сервер принимает запись с устаревшим контекстом, чтобы сохранить независимую правку клиента. При условной записи сервер атомарно проверял бы актуальность контекста и отклонял устаревший запрос. Тогда второй клиент должен был бы прочитать и учесть A₂ перед повторной записью: история принятой A₃ на этом сервере стала бы непрерывной. Это другой протокол, требующий повторных попыток при конкуренции. При нашем протоколе пропуск сохраняется, и его описывает dot.
В этом протоколе get(key) возвращает все актуальные версии, известные читаемой реплике, и их общий контекст. Протокол поддерживает инвариант: объединение историй этих версий содержит по каждому серверу непрерывный префикс правок. Поэтому общий контекст можно представить обычным вектором. В примере объединение {A₁, A₂} и {A₁, A₃} даёт {A₁, A₂, A₃}, то есть {A:3}. Историю одной версии {A₁, A₃} так сжать нельзя — в ней есть пропуск A₂.
Клиент учитывает полученные значения и передаёт их общий контекст вместе с новой записью. Реплика удаляет siblings, чьи метки dot покрывает этот контекст: для dot (A,n) это означает n <= context[A]. Для контекста, полученного по данному протоколу, включение dot версии означает, что учтена и её причинная история. Остальные siblings сохраняются. Следующая запись с контекстом {A:3} и новым dot (A,4) заменит обе версии из примера.
Если put возвращает только OK, перед следующей записью, продолжающей предыдущую, клиент делает get, который уже учитывает его успешную запись. Повторное использование прежнего контекста не сообщает серверу об этой зависимости. Дополнительный get можно опустить, если ответ put возвращает актуальные версии и их общий контекст. При единственной уже известной клиенту версии достаточно вернуть её контекст. Клиент должен учесть значения, связанные с полученным контекстом: простая подстановка свежего контекста в старый текст может затереть непрочитанную правку.
Таким образом, сервер может выдавать идентификаторы записей многим клиентам, сохраняя различие между тем, что уже знает сервер, и тем, что прочитал конкретный клиент. Разбор DVV в Riak показывает, как это помогает точно определять, какие siblings заменяет обновление. Инвариант общего контекста и протокол чтения и записи описаны в статье о DVV, §4.1 и §5.3.
Модели согласованности
Когда мы работаем с распределенной системой, мы хотим, чтобы данная система внешне вела себя как один компьютер. Однако внутри себя данная система состоит из нескольких узлов, которые могут изменять общее состояние. Более того, зачастую система позволяет делать конкурентные запросы.
Было бы разумно ввести семантику конкурентных запросов: какие гарантии мы получаем касательно данных, которые будут возвращены? Учитывая, что узлы хранят собственную копию состояния, необходимо определить, какое поведение считается допустимым при обработке конкурентных запросов на запись и чтение.
Модель согласованности (consistency model) это контракт между распределенной системой и её клиентом, позволяющий понять, какие гарантии предоставляет система касательно запросов к данным.
При разделении сети (network partition) узлы могут оказаться в изолированных частях. В этих условиях нельзя гарантировать одновременно линеаризуемость и доступность каждой операции на каждом исправном узле. Для сохранения линеаризуемости части запросов придётся ждать восстановления связи или завершаться отказом. Если все части продолжают независимо обслуживать чтения и записи, линеаризуемость гарантировать нельзя. Это ограничение описывает теорема CAP.
С точки зрения клиентов логично ожидать от системы, чтобы она вела себя так, будто конкурентных запросов не существует, а их обработка происходит в некотором порядке. В идеале поведение системы должно быть неотличимо от работы с единственной копией данных. Однако чем строже (ближе к идеалу) модель согласованности, тем сложнее этого добиться, что сказывается на ограничениях и скорости работы системы. Компромисс между согласованностью и задержкой в условиях нормальной работы сети описан в принципе PACELC.
Слева показаны модели изоляции транзакций, справа — модели согласованности отдельных операций. Последовательная и причинная согласованность могут описывать операции над несколькими объектами.
С описанием многих моделей согласованности можно ознакомиться на ресурсе Jepsen (схема кликабельна), мы затронем лишь несколько из них.
Causal Consistency
Причинная согласованность требует, чтобы клиент, которому видна запись, мог наблюдать и все её причинные зависимости. Конкурентные изменения клиенты могут видеть в разном порядке.
Рассмотрим ситуацию с тремя узлами: узел A отправляет другим узлам сообщение "Поедим?". Узлы B и C независимо друг от друга рассылают ответы "да" и "нет" соответственно. Causal consistency позволяет узлам наблюдать сообщения в порядке ("Поедим?", "да", "нет") или ("Поедим?", "нет", "да"). Однако никакой узел не должен наблюдать сообщения "да" и "нет" до сообщения "Поедим?".
При причинной рассылке из семинара 4 это требование относится к доставке сообщений приложению. Поверх надёжной рассылки одной группе участников используется вектор D: компонента D[j] показывает, сколько первых сообщений отправителя j уже доставлено приложению. Изначально все компоненты равны нулю.
Отправитель прикладывает к сообщению вектор зависимостей deps. В него копируется локальный D, а собственная компонента заменяется числом ранее отправленных сообщений. Рассылка включает и самого отправителя, а повторное получение того же сообщения не вызывает повторной доставки. Так сообщение зависит и от ранее доставленных отправителю сообщений, и от всех его предыдущих рассылок.
Получатель помещает сообщение в буфер. Доставка разрешена, когда deps <= D покомпонентно. После доставки сообщения отправителя j увеличивается только D[j], затем буфер проверяется снова. Пока сообщение лишь получено по сети и ждёт в буфере, D не меняется.
Обычные векторные часы учитывают также локальные события и сетевые получения. При получении сообщения их обновление может перенести сведения о предшествующем сообщении, которое ещё не доставлено приложению. Поэтому для проверки доставки используется отдельный вектор D. Алгоритм причинной рассылки у Клеппмана, §4.3.
Например, рассмотрим вопрос A и ответ B при порядке компонент (A,B,C). Вопрос несёт deps = (0,0,0), ответ после доставки вопроса на B — deps = (1,0,0). Если C сначала получит ответ, при D = (0,0,0) он останется в буфере. После доставки вопроса D = (1,0,0), поэтому ответ можно доставить, получив D = (1,1,0).
Sequential Consistency
Leslie Lamport определяет модель последовательной согласованности (sequential consistency) следующим образом:
the result of any execution is the same as if the operations of all the processors were executed in some sequential order, and the operations of each individual processor appear in this sequence in the order specified by its program.
Менее формально, SC предполагает, что все операции выполняются согласно некоторому полному порядку, который согласован с локальными порядками выполнения операций на каждом из узлов.
Рассмотрим два узла и две переменные, изначально x = y = 0. Узел A сначала читает x, затем y. Узел B сначала записывает y = 1, затем x = 1.
Зелёные блоки показывают несколько допустимых общих порядков операций. Каждый сохраняет порядок действий обоих узлов, а чтения возвращают значения последних предшествующих им записей. В четвёртом зелёном блоке обе записи стоят перед чтениями, поэтому A получает x = 1 и y = 1.
Красный блок показывает недопустимый порядок: запись x = 1 стоит раньше записи y = 1, вопреки программе B. При этом сами результаты чтений (1, 1) допустимы — их объясняет четвёртый зелёный блок. Чтобы история удовлетворяла SC, достаточно найти хотя бы один общий порядок, сохраняющий порядок каждого узла и объясняющий все результаты чтений.
Если A прочитал x = 1, то в допустимом общем порядке запись x = 1 уже произошла. Перед ней B записал y = 1, а чтение y у A следует за чтением x. Поэтому в этом примере второе чтение должно вернуть y = 1: результат (1, 0) не допускается ни при одном подходящем порядке. При этом SC не требует сохранять реальный порядок операций разных клиентов, если между ними нет других ограничений.
Linearizability
Отступление про истории
Рассмотрим систему, поддерживающую базовый набор операций: запись и чтение. Операции требуют некоторое время на обработку, то есть у каждой операции есть время её начала и время окончания выполнения (когда мы получаем ok). Также наша система будет поддерживать возможность конкурентных операций, интервалы выполнения которых пересекаются.
Введём понятие истории (history). Это упорядоченный список вызовов операций и ответов на них. У завершённой операции есть вызов и ответ; незавершённая пока представлена только вызовом.
История позволяет отразить логику выполнения конкурентных операций. Рассмотрим следующую диаграмму, на которой нанесены операции, выполняющиеся ненулевое время:
Для данной диаграммы можно выписать следующую историю:
C: write y=5
A: read x
B: read y
C: ok [write y=5]
A: ok [read x]
B: ok [read y]
A: write x=10
A: ok [write x=10]
C: read x
C: ok [read x]
Линеаризуемость
Формально свойство линеаризуемости определяется в Linearizability: A Correctness Condition for Concurrent Objects.
Назовём историю последовательной (sequential history), если после каждого начала операции сразу же следует ответ на данную операцию. Важно учитывать, что по умолчанию, когда говорят про линеаризуемость, имеют в виду работу с одним объектом.
Например, следующая история не является последовательной, так как в ней есть пересекающиеся операции:
read x
write x
ok [read x]
ok [write x]
Сначала рассмотрим историю, в которой все операции завершены. Назовём такую историю H линеаризуемой, если она эквивалентна некоторой корректной последовательной истории H', где H' состоит из тех же событий, но возможно расположенных в другом порядке с ограничением, что если операция op1 заканчивается раньше начала операции op2 в H, то такой же порядок сохраняется и в H'. Другими словами, история линеаризуема, если все ответы на операции корректны в соответствии с последовательным реордерингом, сохраняющим порядок непересекающихся операций.
Если в истории есть незавершённые вызовы, для проверки можно дополнить часть из них ответами, а остальные отбросить. Это позволяет учесть операцию, которая уже повлияла на состояние, хотя клиент ещё не получил ответ.
Наконец, назовём объект линеаризуемым, если все истории, которые он порождает, являются линеаризуемыми. Другими словами, неважно как и когда клиенты выполняют запросы, результат их выполнения можно представить таким образом, будто запросы шли один за другим с сохранением реального порядка непересекающихся операций.
Рассмотрим изначально пустую FIFO-очередь. Следующая история не линеаризуема:
A: push 0
A: ok [push 0]
B: push 1
C: pop
B: ok [push 1]
C: ok [1]
История не линеаризуема, так как операция pop на узле C началась после завершения операции push 0 на узле A, а значит результатом pop должен быть 0 (по семантике очереди).
Следующая история является линеаризуемой:
A: write 0
A: ok [write 0]
B: write 1
C: read
B: ok [write 1]
C: ok [0]
так как мы можем делать реордеринг пересекающихся операций и можем привести рассмотренную историю к последовательной:
A: write 0
A: ok [write 0]
C: read
C: ok [0]
B: write 1
B: ok [write 1]
А теперь менее формально
Если у клиентов системы появляется внешний (по отношению к системе) канал общения, по которому они могут передавать друг другу информацию о прочитанных значениях / событиях, гарантий Sequential Consistency может не хватить.
Линеаризуемость помогает учесть наличие внешнего канала общения и предполагает, что операции выполняются атомарно, в порядке, согласованном с порядком выполнения операций в реальном времени. Для внешних клиентов результаты обработки выглядят так, будто они применяют атомарные операции к единственной копии объекта.
Если операция A в реальном времени заканчивается раньше, чем начинается операция B, значит обработка операции B должна происходить над состоянием после применения операции A.
На практике данная модель согласованности запрещает подобные ситуации:

Пример из книги Designing Data-Intensive Applications, Martin Kleppman
Данную ситуацию можно описать следующей историей:
# set 0
A: write 1
A: ok [write 1]
B: read
B: ok [1]
# external communication happened here
C: read
C: ok [0] # (!)
Для пересекающихся операций могут допускаться несколько результатов: например, чтение, пересекающееся с записью, может вернуть старое или новое значение. Но все ответы вместе должны объясняться одной допустимой последовательной историей:
Если чтение вернуло новое значение, то чтения, начатые после его завершения, тоже должны возвращать это значение, пока его не заменит следующая запись:
В линеаризуемой истории каждой завершённой операции можно назначить точку линеаризации между её вызовом и ответом. Результаты всех операций должны соответствовать их атомарному выполнению в порядке этих точек на одной копии объекта. Реплики могут применять изменения в разное время, но обработка запросов должна сохранять такое наблюдаемое поведение.
Пример из книги Designing Data-Intensive Applications, Martin Kleppmann. На рисунке cas(x, old, new) заменяет значение только при совпадении с old. Последнее чтение B с результатом 2 нарушает линеаризуемость: оно начинается после чтения A, уже вернувшего 4, а новых записей после 4 нет.
Для достижения описанных гарантий на практике прибегают к механизму взятия блокировок и алгоритмам консенсуса.
Linearizability vs Sequential Consistency
Обе модели требуют одного общего последовательного порядка операций, сохраняющего порядок каждого клиента. Для регистра чтение возвращает значение последней предшествующей ему записи в этом общем порядке.
Различие — в требованиях к реальному времени. Sequential consistency позволяет переставлять операции разных клиентов, даже если их интервалы не пересекались. Линеаризуемость дополнительно требует: операция, завершившаяся до начала другой, должна стоять раньше неё.
Например, при начальном x = 0 клиент A записал x = 1 и получил подтверждение. Затем другой клиент B прочитал x = 0. Для SC это допустимо: чтение B можно поставить перед записью A, сохранив порядок действий каждого клиента. Для линеаризуемости это запрещено, поскольку запись завершилась до начала чтения.
Разрешение конфликтов
В качестве примера давайте рассмотрим следующие задачи:
- реализовать коллаборативный редактор (Google Docs);
- реализовать синхронизацию календаря на разных устройствах при условии, что устройства иногда уходят "в оффлайн";
- посчитать число просмотров популярного сайта (google.com).
Для решения подобных задач можно прибегнуть к подходам автоматического разрешения конфликта. Данные алгоритмы способны работать в системах, где записи генерируются на нескольких узлах, узлы могут уходить в "оффлайн", и необходимо синхронизовать изменения между узлами. При этом требуется обеспечить свойство сходимости (convergence) - все узлы должны прийти к одинаковому состоянию после того, как получат все изменения.
У CRDT (Conflict-free Replicated Data Types) любые две реплики, учтя один и тот же набор обновлений, имеют одинаковое наблюдаемое состояние. При условии, что все обновления в итоге достигают всех исправных реплик, это даёт сильную согласованность в конечном счёте (strong eventual consistency, SEC). В частности, после прекращения записей и завершения обмена состояния реплик совпадут, как требует eventual consistency. Пока наборы учтённых обновлений различаются, результаты чтений могут отличаться.
Выявив конкурентные версии, можно выбрать разные правила разрешения конфликта:
- Last Write Wins (LWW): выбрать значение с наибольшей временной меткой, предусмотрев правило для равных меток. Остальные изменения теряются; при физических метках выбор зависит и от точности часов.
- Объединение приложением: вернуть siblings и дать приложению построить итоговое значение, как в примере с Dynamo.
- CRDT: заранее определить операции над данными и правила слияния так, чтобы реплики сходились при обмене всеми изменениями.
Эти подходы могут сочетаться. Например, LWW-регистр — CRDT, хранящий пару (метка, значение). Метки уникальны и полностью упорядочены. Каждая новая запись получает метку больше всех меток этого регистра, известных локальной реплике. Для этого подходят пары (метка Лэмпорта, идентификатор узла) с лексикографическим сравнением. При слиянии выбирается пара с большей меткой, поэтому порядок и повторение обменов не влияют на результат.
Один LWW-регистр для всей карточки товара выберет одну её редакцию. Если у каждого поля свой LWW-регистр, независимые изменения размера и цвета смогут сохраниться вместе. Оба варианта являются CRDT и обеспечивают сходимость.
Другой подход — Operational Transformation (OT): операции преобразуются с учётом конкурентных изменений. Например, позиция вставки сдвигается, если перед ней уже вставили другой символ. Конкретные алгоритмы различаются способом упорядочивания и преобразования операций; подробно OT здесь не рассматриваем.
State-based CRDT - разновидность структур данных Conflict-free Replicated Data Types (CRDT), которые позволяют обойтись без центрального сервера. Их идея заключается в том, что можно определить удобную операцию merge для двух состояний, применяя которую мы будем автоматически разрешать конфликты (детерминированно).
Потребуем от операции merge следующие свойства:
- коммутативность: merge(x, y) = merge(y, x);
- ассоциативность: merge(x, merge(y, z)) = merge(merge(x, y), z);
- идемпотентность: merge(x, x) = x.
Данными свойствами, например, обладают операции взятия максимума из двух элементов или операция объединения множеств.
Кроме свойств merge, нужны ограничения на локальные изменения. В стандартной модели state-based CRDT состояния частично упорядочены и образуют полурешётку: для любой пары есть наименьшая общая верхняя грань, и merge возвращает именно её. Порядок задаётся для конкретного типа; например, в G-Counter это покомпонентное сравнение векторов. Каждый локальный переход должен сохранять s \leqslant s', где s — состояние до изменения, s' — после. Например, компоненты G-Counter только растут; уменьшение могло бы отмениться при слиянии со старой копией. Растёт внутреннее состояние с метаданными, а наблюдаемое значение может и уменьшаться, как в PN-Counter. Определение state-based CRDT, §2.3.1.
Рассмотрим примеры реализации примитивов с помощью данного подхода.
G-Counter (grow-only counter)
Это простейший монотонно увеличивающийся счетчик. Например, такой примитив подходит для подсчета числа визитов сайта google.com.
Каждый узел считает принятые им инкременты. Нужно объединить эти счётчики так, чтобы повторная доставка состояния и изменение порядка сообщений не приводили к повторному учёту инкрементов.
Вспомним идею векторных часов. На каждой реплике будем хранить вектор из счетчиков, i-я компонента вектора будет соответствовать счетчику на i-ом узле.
-
Когда узел хочет сделать инкремент счетчика, он увеличивает значение в своей компоненте и может разослать свой вектор остальным узлам.
-
Когда узел получает вектор от другого узла, он делает операцию покомпонентного максимума своего вектора с полученным.
-
Чтобы определить суммарное значение счетчика, узел считает сумму всех компонент вектора.
Пока часть обновлений не дошла, значение может отставать от общего числа инкрементов. После доставки всех обновлений оно будет точным: каждый инкремент учтётся ровно один раз.
PN-Counter (positive-negative counter)
Чтобы поддержать возможность декремента счетчика, необходимо взять два G-Counter счетчика. В одном будем поддерживать сумму инкрементов, в втором — декрементов.
Чтобы определить значение счётчика, из суммы первого вектора вычитают сумму второго. Слияние выполняют отдельно для каждого вектора покомпонентным максимумом. Обе части растут, хотя их разность может уменьшаться.
PN-Counter не гарантирует неотрицательное количество товара: если две реплики независимо уменьшают остаток 1 на единицу, после слияния получится −1. Если оба действия означали удаление одной и той же упаковки, нужны сведения о том, какую упаковку удаляют. Ниже увидим, как для этого использовать метки добавлений.
G-Set (grow-only set)
Для реализации структуры типа множество (set), поддерживающей только добавление новых элементов, в качестве merge достаточно взять стандартную операцию объединения множеств.
Если просто удалить элемент на одной реплике, слияние со старым состоянием другой реплики вернёт его обратно. Для поддержки удаления нужно хранить дополнительную информацию.
OR-Set (observed-remove set)
В OR-Set каждое добавление элемента получает уникальную метку, например dot (узел, счётчик). Даже повторные добавления одного x имеют разные метки. Операция remove(x) удаляет только те добавления x, которые она наблюдала.
Простую state-based реализацию можно описать двумя множествами: E хранит пары (элемент, метка), а T — удалённые метки (tombstones):
add(x): создать новую уникальную меткуdи добавить(x,d)вE;remove(x): добавить вTметки всех известных пар(x,d)изE;contains(x): проверить, что вEесть пара(x,d), для которойdотсутствует вT;merge: объединить множества добавлений и удалений отдельно:E = E₁ ∪ E₂,T = T₁ ∪ T₂.
Оба множества только растут, а их объединение коммутативно, ассоциативно и идемпотентно. Сведения об удалениях сохраняются, поэтому старые состояния не воскрешают удалённые добавления.
Например, обе реплики знают добавление (x, A₁). Первая выполняет remove(x) и помечает A₁ удалённой. Вторая независимо выполняет add(x) с новой меткой B₁. После слияния A₁ удалена, но B₁ остаётся: x присутствует во множестве. Это семантика add-wins при конкурентных добавлении и удалении. Если удаление произошло после наблюдения обеих меток, оно удалит обе.
Для учёта упаковок можно сопоставить каждой упаковке отдельную метку и считать активные метки товара. Два удаления одной метки оставят её удалённой один раз. При этом команда «убрать одну упаковку» должна указывать выбранную метку; обычный remove(x) выше убирает все наблюдавшиеся добавления товара.
Связь с DVV: dot идентифицирует отдельное изменение, а сведения о наблюдавшихся изменениях определяют, что операция может заменить или удалить. В этой простой реализации такие сведения хранятся явно; оптимизированные OR-Set используют причинный контекст для сокращения метаданных.
Сходимость CRDT сама по себе не гарантирует последовательной согласованности. Рассмотрим пустую корзину как OR-Set, где удаление убирает товар целиком. Без связи между репликами клиенты выполняют следующие действия:
| Клиент | Локальные действия по порядку |
|---|---|
| Анна | Добавить чай, добавить кофе, убрать чай |
| Борис | Добавить кофе, добавить чай, убрать кофе |
При слиянии сохраняются добавление кофе Анной и добавление чая Борисом: каждое удаление отменило только собственное добавление соответствующего товара. После обмена оба клиента читают корзину и видят чай и кофе.
При любом последовательном выполнении этих действий с сохранением порядка каждого клиента последним изменением было бы одно из удалений. Выполнивший его клиент при своём последующем чтении не мог бы увидеть оба товара, поскольку новых добавлений уже нет. Значит, реплики сошлись, хотя единая последовательная история не объясняет оба чтения. Подробнее о таких историях OR-Set у Алмейды, §3.3.
Коллаборативный редактор
Для совместного редактирования текста можно использовать CRDT последовательности со стабильными идентификаторами символов. На рисунке показана идея упорядоченных позиций: символу при вставке между соседями назначается рациональное число между их позициями, например среднее. Добавление других символов не меняет уже выданные позиции:
Credits to Martin Kleppman
Этой схемы недостаточно для полного редактора. При конкурентной вставке в один промежуток два узла могут выбрать одинаковое среднее; нужны уникальные идентификаторы символов и общее правило их упорядочивания. Удаление должно ссылаться на идентификатор символа, а сведения о нём — корректно сохраняться при слиянии. Кроме того, повторное деление интервала исчерпывает точность обычного float, поэтому для позиций нужны расширяемые представления. Подробнее у Клеппмана, §8.1.
Изучить логику работы коллаборативного редактора на основе OT можно здесь.
JSON
Библиотека Automerge предоставляет CRDT для совместного редактирования JSON-подобных документов, включая объекты, списки и текст. Для разных типов данных заданы свои правила слияния.
При конкурентной записи разных значений одного свойства Automerge детерминированно показывает одно из них, а остальные сохраняет и позволяет получить через getConflicts. Приложение может предложить пользователю разрешить такой конфликт. Документация о конфликтах. Сходимость документа сама по себе не проверяет прикладные ограничения, например согласованность связанных полей.
Другие примеры
Не будем пересказывать логику реализации других примитивов, так как лучше всего ознакомиться с оригинальными статьями, ссылки на которые есть в конце.
CRDT структуры очень интересны и с помощью изящных приемов позволяют решить довольно сложные задачи.
Дополнительные материалы
- TrueTime API
- Spanner, TrueTime & The CAP Theorem
- Time, Clocks, and the Ordering of Events in a Distributed System — статья Лесли Лэмпорта про логические часы.
- Virtual Time and Global States of Distributed Systems — работа Фридемана Маттерна о векторном времени, используемая в лекции.
- Timestamps in Message-Passing Systems That Preserve the Partial Ordering — независимая работа Колина Фиджа о векторных часах.
- Dynamo: Amazon's Highly Available Key-value Store — интерфейс с контекстом и версии данных, секции 4.1 и 4.4.
- Dotted Version Vectors: Logical Clocks for Optimistic Replication — причинный контекст и отдельный идентификатор обновления.
- A comprehensive study of Convergent and Commutative Replicated Data Types — определения CRDT и примеры, включая OR-Set.
- Jepsen Consistency Models — краткое описание моделей согласованности.
- CSE Buffalo 26 consistency — разница Linearizability и Sequential Consistency.
- Living without atomic clocks: Where CockroachDB and Spanner diverge
- CockroachDB's consistency model — про линеаризуемость в глобально-распределенной СУБД CockroachDB.
- Designing Data-Intensive Applications, Martin Kleppman — хорошая книга, раскрывающая многие концепции распределенных систем.
- Distributed Systems 8.1: Collaboration software — Мартин Клеппман доступным языком рассказывает базовые подходы в CRDT и OT.
- An introduction to state-based CRDTs — хорошая серия статей про CRDT.
- Автоматическое разрешение конфликтов с помощью операциональных преобразований — неплохая статья на русском языке про OT.
- To OT or CRDT, that is the question — про ситуации, когда CRDT хуже отражают намерение, или почему OT все еще жив.