1000 элементов, 1000 узлов, 3 элемента на узел, лучшая схема репликации для минимизации потери данных при сбое узлов?

Я думал о таких методах, как уровни RAID, но Skiena говорит: "каждый узел может хранить копии ровно трех разных элементов.- Даже при том, что XOR'Red битовые шаблоны двух отдельных данных могут храниться в одном и том же объеме пространства, я не думал, что это было то, что проблема искала.

Итак, я начал с того, что подумал OP: храните три копии каждого из данных своим следующим двум соседям полосатым способом. Например, следующее Для когда N==6 и данные целые числа от 0 до 5 (4 и 5 обертываются и используют узлы 0 и 1):

nodes:    0 1 2 3 4 5
          ===========
copy 0 -> 0 1 2 3 4 5 
copy 1 -> 5 0 1 2 3 4 
copy 2 -> 4 5 0 1 2 3 

из всех 20 комбинаций сбоев трех узлов есть шесть, которые теряют ровно одну часть данных. Например; когда узлы 1, 2 и 3 терпят неудачу, данные 1 теряются:

===========
0 X X X 4 5 
5 X X X 3 4 
4 X X X 2 3 

похожие друг на друга данные, что делает 6 из 20 комбинаций потерять данные. Поскольку Skiena не описывает, что означает "потеря данных" для приложения: означает ли потеря одной точки данных, что вся сбор теряется впустую, или потеря одной точки данных приемлема и лучше, чем потеря двух?

если потеря даже одной точки данных означает, что вся коллекция является даром, то мы можем сделать лучше. В три раза лучше! :)

вместо того, чтобы распределять копии данных по правым узлам полосатым способом, определите группы из трех узлов, которые совместно используют данные. Например, пусть 0, 1 и 2 делятся своими данными, а 3, 4 и 5 - своими данные:

nodes:    0 1 2 3 4 5
          ===========
copy 0 -> 0 1 2 3 4 5
copy 1 -> 2 0 1 5 3 4
copy 2 -> 1 2 0 4 5 3

на этот раз, только 2 из 20 комбинаций производят потерю данных всегда. Данных 0, 1 и 2 теряются вместе, когда узлы 0, 1 и 2 плохо:

===========
x x x 3 4 5
x x x 5 3 4
x x x 4 5 3

и данные 3, 4 и 5 теряются вместе, когда узлы 3, 4 и 5 терпят неудачу:

===========
0 1 2 x x x
2 0 1 x x x
1 2 0 x x x

это составляет всего 2 из 20 комбинаций сбоев трех узлов. Когда одни и те же узлы используют одни и те же данные, это эффективно объединяет потери данных в меньшее количество сочетания.

Али

да,

 D = {1,...,d_i,...,d} denote the data items and d_i a given data element
 N = {1,...,n_k,...,n} denote the storage cluster and n_k a given storage node. 
 We say d_i is stored by n_k, loosely denoted by d_i \in n_k.

моя модель репликации имеет следующие допущения:

1 - каждый элемент данных должен храниться, по крайней мере, в одной заданной вершины во время инициализации. Т. е.:

   Exist at least one 1 <= k <=n s.t. P(d_i \in n_k) = 1.

2-из (1), во время инициализации вероятность нахождения d_i в данном узле составляет не менее 1/n. То есть:

   For any data item 1 <= i <= d and a random node n, P(d_i \in n) >= 1/n. 

учитывая постановку проблемы, по дизайну мы хотим иметь это равномерное распределение по набору данных.

3 - Наконец, дизайн, вероятность того, что элемент данных d_i будет находиться в данном узле n, должна быть независимой между элементами данных. Т. е.:

  P(d_i \in n | d_j \in n) = P(d_i \in n)

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

из этих предположений я предложил следующую модель репликации (для экземпляра проблемы, где d = n и каждый узел хранит ровно 3 различных данных поставки.)

(1) Выполните случайную перестановку набора данных. (2) используя скользящее окно длины 3 и шага 1, поверните перетасованный набор данных и сопоставьте элементы данных каждому узлу.

E.g.:
D = {A,B,C,D}
N = {1,2,3,4}

(1) {C, B, A, D}
(2) 1 -> {C, B, A}, 2 -> {B, A, D}, 3-> {A, D, C}, 4-> {D, C, B}

случайное перемешивание обеспечит независимое (3) и равномерное распределение (2). Пока сползая окно шага 1 гарантирует (1).

обозначим скользящее окно данного узла n_k как упорядоченное множество w_k = {w_k1, w_k2, w_k3}. n_k как говорят, быть хозяином узел для w_k1 (первый элемент w_k). Любой другой узел n_j, содержащий w_k1, является узлом реплики. N. B.: предлагаемая модель репликации гарантирует только один главный узел для любого d_i, в то время как количество узлов реплики зависит от длины окна.

в приведенном выше примере: n_1-главный узел для узлов реплики C и n_3 и n_4.

вернемся к исходной проблеме, учитывая эту схему, мы можем заявить, что вероятность потери данных-это потеря главного узла и всех реплик для данный элемент данных.

P(d_i потерян) = P (главный узел для d_i терпит неудачу и реплика 1 терпит неудачу и реплика 2 терпит неудачу).

без формального доказательства беспристрастная случайная перестановка на шаге (1) выше приведет к

П(d_i теряется) = Р(мастер-узел не d_i) * Р(реплика 1 не выполняется) * Р(реплика 2 не удается).

опять же, случайная перестановка является эвристикой для абстрактного совместного распределения для отказа узлов.

из предположений (2) и (3), P (d_i теряется) = c, для любого d_i, во время инициализации.

это сказано для d = n = 1000 и коэффициента репликации 3 (т. е.: длина окна равна 3).

P (d_i потеряно) = 1/1000 * 1/999 * 1/998 ~ 10^-9

ваш подход кажется по существу правильным, но может извлечь выгоду из стратегии отработки отказа. Обратите внимание, что профессор Скиена попросил "минимизировать потерю данных при сбое узлов", что предполагает, что отказ узлов будет обычным явлением.

вы можете посмотреть последовательный хэширования.

кроме того, есть Великий пост инженерами reddit об опасностях не использовать последовательное хеширование (вместо этого используя фиксированное хеширование MOD).