Часть 2 Фундаментальные алгоритмы 6 глава

Маркер < tok,p_i> передается ровно i раз, если p_i является наименьшим из идентификаторов от p₁ до p_i, что имеет место в (1/i)*(N-1)! расположениях; итак

 

Маркер < tok,p_i> передается не менее k раз (здесь k £ i), если за процессом p_i следует k-1 процесс с идентификаторами, большими p_i. Количество расположений, в которых p_i - наименьший из k идентификаторов p_i-k+1,..., p_i, составляет 1/k часть всех расположений, т.е. (1/k)*(N-1)!. Теперь, для k<i  < tok,p_i> передается ровно k раз, если он передается не менее, но и не более k раз, т.е. ³ k раз, но не ³ k+1 раз. В результате количество расположений, где это выполняется, равно, т.е.  (для k < i).

Общее количество передач < tok,p_i> во всех расположениях равно:

,

что равняется. Сумма известна как i-е гармоническое число, обозначаемое H _i. В качестве Упражнения 7.3 оставлено доказательство тождества.

Далее мы суммируем по i количество передач маркера, чтобы получить общее количество передач (исключая передачи < tok,s>) во всех расположениях. Оно равно

.

Добавляя N(N-1)! передач маркера для < tok,s>, мы получаем общее количество передач, равное

.

Т.к. это число выведено для (N-1)! различных расположений, среднее по всем расположениям, очевидно, равно N× H _N, что составляет»0.69N logN (см. Упр.7.4).

7.2.2 Алгоритм Petersen / Dolev-Klawe-Rodeh

Алгоритм Чанга-Робертса достигает сложности сообщений O(N logN) в среднем, но не в наихудшем случае. Алгоритм со сложностью O(N logN) в наихудшем случае был дан Франклином [Franklin; Fra82], но этот алгоритм требует, чтобы каналы были двунаправленными. Petersen [Pet82] и Dolev, Klawe, Rodeh [DKR82] независимо разработали очень похожий алгоритм для однонаправленных колец, решающий задачу с использованием только O(N logN) сообщений в наихудшем случае. Алгоритм требует, чтобы каналы подчинялись дисциплине FIFO.

Сначала алгоритм вычисляет наименьший идентификатор и сообщает его каждому процессу, затем процесс с этим идентификатором становится лидером, а все остальные терпят поражение. Алгоритм легче понять, если представить, что он выполняется идентификаторами, а не процессами. Изначально каждый идентификатор активен, но на каждом круге некоторые идентификаторы становятся пассивными, как будет показано позднее. При обходе круга активный идентификатор сравнивает себя с двумя соседними активными идентификаторами по часовой стрелке и против нее. Если он является локальным минимумом, он остается в круге, иначе он становится пассивным. Т.к. все идентификаторы различны, идентификатор рядом с локальным минимумом сам не является локальным минимумом, откуда следует, что не менее половины идентификаторов выбывают из круга при каждом обходе. Следовательно, после не более чем logN кругов остается только один активный идентификатор, который и является победителем.

Рис.7.6 Процесс p получает текущие идентификаторы q и r.

Этот принцип может быть непосредственно реализован в двунаправленных сетях, как это сделано в алгоритме Франклина [Fra82]. В ориентированных кольцах сообщения можно посылать только по часовой стрелке, что затрудняет получение соседнего активного идентификатора в этом направлении; см. Рис. 7.6. Идентификатор q нужно сравнить с r и p; идентификатор r можно послать q, но идентификатор p нужно было бы передавать против направления каналов. Чтобы сравнить q и с r, и с p, идентификатор q передается (в направлении кольца) процессу, который имеет идентификатор p, а r передается не только процессу с идентификатором q, но и дальше, процессу с идентификатором p. Если q является единственным активным идентификатором в начале обхода круга, первый идентификатор, который q встречает при обходе, равен q (т.е. в этом случае p = q). Когда это происходит, идентификатор q выигрывает выборы. 

Алгоритм для процессов в однонаправленном кольце обозначен как Алгоритм 7.7. Процесс p является активным в круге, если он в начале круга имеет активный идентификатор ci_p. Иначе p является пассивным и просто пропускает через себя все получаемые сообщения. Активный процесс посылает свой текущий идентификатор следующему активному процессу, и получает текущий идентификатор предыдущего активного процесса, используя сообщения < one,·>. Полученный идентификатор сохраняется (в переменной acn_p), и если он не выбывает из круга, он будет текущим идентификатором p в следующем круге. Чтобы определить, остается ли идентификатор acn_p в круге, его сравнивают с ci_p и активным идентификатором, полученным в сообщении < two,·>. Процесс p посылает сообщение < two,acn_p>, чтобы следующий активный процесс мог провести такое же сравнение. Исключение возникает, когда acn_p = ci_p; в этом случае остался один активный идентификатор и об этом сообщается всем процессам в сообщении < smal,acn_p>.

 

var ci_p    : P init p; (* Текущий идентификатор p *)

  acn_p  : P init udef; (* Идентификатор соседа против часовой стрелки *)

  win_p : P init udef; (* Идентификатор победителя *)

  state_p: (active, passive, leader, lost) init active;

 

begin if  p - инициатор then state_p:= active else state_p:= passive;

       while win_p = udef do

            begin if state_p = active then

                            begin send < one,ci_p>; receive < one,q>; acn_p:= q;

                                        if acn_p = ci_p then (* acn_p - минимум *)

                                             begin send < smal,acn_p>; win_p:= acn_p;

                                                      receive < smal,q>

                                             end

                                        else (* acn_p - текущий идентификатор соседа *)

                                             begin send < two,acn_p>; receive < two,q>;

                                                      if acn_p < ci_p and acn_p < q

                                                           then ci_p:= acn_p

                                                           else state_p:= passive

                                             end

                            end

                       else (* state_p = passive *)

                            begin receive < one,q>; send < one,q>;

                                       receive m; send m; 

                                       (* m - либо < two,q>, либо < smal,q> *)

                                        if m - < smal,q> then win_p:= q

                            end

            end;

       if p = win_p then state_p:= leader else state_p:= lost

End

Алгоритм 7.7 Алгоритм Petersen / Dolev-Klawe-Rodeh.

 

Теорема 7.7 Алгоритм 7.7 решает задачу выбора для однонаправленных сетей с использованием O(N logN) сообщений.

Доказательство. Будем говорить, что процесс находится на i-м круге, когда он выполняет основной цикл в i-й раз. Обходы круга не синхронизированы глобально; возможно, что в различных частях кольца один процесс на несколько кругов впереди другого. Но, т.к. каждый процесс отправляет и получает в каждом круге ровно по два сообщения и каналы подчиняются дисциплине FIFO, то сообщение всегда будет получено в том же круге, в каком оно было послано. На первом круге все инициаторы активны и все имеют различные «текущие идентификаторы».

Утверждение 7.8 Если круг i начинается с k (k>1) активными процессами, и все процессы имеют различные ci, то в круге остаются не меньше 1 и не больше k/2 процессов. В конце круга снова все текущие идентификаторы активных процессов различны и включают наименьший идентификатор.

Доказательство. Путем обмена сообщениями < one,q>, которые пропускаются пассивными процессами, каждый активный процесс получает текущий идентификатор своего активного соседа против часовой стрелки, который всегда отличается от его собственного идентификатора. Далее, каждый активный процесс продолжает обход круга, передавая сообщения < two,q>, благодаря которым каждый активный процесс получает текущий идентификатор своего второго активного соседа против часовой стрелки. Теперь все активные процессы имеют различные значения acn, откуда следует, что в конце круга все оставшиеся в круге идентификаторы различны. По крайней мере, остается идентификатор, который был наименьшим в начале круга, т.е. остается хотя бы один процесс. Идентификатор рядом с локальным минимумом не является локальным минимумом, откуда следует, что количество оставшихся в круге не превышает k/2.

Из Утверждения 7.8 следует, что существует круг с номером £ ëlogNû+1, который начинается ровно с одним активным идентификатором, а именно, с наименьшим среди идентификаторов инициаторов.

Утверждение 7.9 Если круг начинается ровно с одним активным процессом p с текущим идентификатором ci_p, то алгоритм завершается после этого круга с win_q = ci_p для всех q.

Доказательство. Сообщение < one,ci_p> пропускается всеми процессами и, в конце концов, его получает p. Процесс p обнаруживает, что acn_p = ci_p и посылает по кольцу сообщение < smal,acn_p>, вследствие чего все процессы выходят из основного цикла с win_p = acn_p.

Алгоритм завершается в каждом процессе и все процессы согласовывают идентификатор лидера (в переменной win_p); этот процесс находится в состоянии лидер, а остальные - в состоянии проигравший.

Всего происходит не более ëlogNû+1 обходов круга, в каждом из которых передается ровно 2N сообщений, что доказывает, что сложность сообщений ограничена 2N logN + O(N). Теорема 7.7 доказана.

Dolev и др. удалось улучшить свой алгоритм до 1.5N logN, после чего Petersen получил алгоритм, использующий только 1.44N logN сообщений. Этот алгоритм снова был улучшен Dolev и др. до 1.356N logN. Верхняя граница в 1.356N logN считалась наилучшей для выбора на кольцах более 10 лет, но была улучшена до 1.271N logN Higham и Przytycka [HP93].

 

7.2.3 Вывод нижней границы

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

Результат получен Pachl, Korach и Rotem [PKR84] при следующих предположениях.

(1) Граница доказывается для алгоритмов, вычисляющих наименьший идентификатор. Если существует лидер, наименьший идентификатор может быть вычислен с помощью N сообщений, а если наименьший идентификатор известен хотя бы одному процессу, процесс с этим идентификатором может быть выбран опять же за N сообщений. Следовательно, сложность задач выбора и вычисления наименьшего идентификатора различаются не более чем на N сообщений.

(2) Кольцо является однонаправленным.

(3) Процессам не известен размер кольца.

(4) Предполагается, что каналы FIFO. Это предположение не ослабляет результат, потому что сложность не-FIFO алгоритмов не лучше сложности FIFO алгоритмов.

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

(6) Предполагается, что алгоритмы управляются сообщениями; т.е. после отправления сообщений при инициализации алгоритма, процесс посылает сообщения в дальнейшем только после получения очередного сообщения. Т.к. рассматриваются асинхронные системы, общие алгоритмы не достигают лучшей сложности, чем алгоритмы, управляемые сообщениями. Действительно, если A - асинхронный алгоритм, то управляемый сообщениями алгоритм B может быть построен следующим образом. После инициализации и после получения любого сообщения B посылает максимальное количество сообщений, которое можно послать в A, не получая при этом сообщений, и только затем получает следующее сообщение. Алгоритм B не только управляется сообщениями, но кроме того, каждое вычисление B является возможным вычислением A (возможно, при довольно пессимистическом распределении задержек передачи сообщений).

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

В этом разделе через s = (s₁,..., s_N), t и т.п. обозначаются последовательности различных идентификаторов процессов. Множество всех таких последовательностей обозначено через D, т.е. D = {(s₁,..., s_k): s_i Î P и i ¹ j Þ s_i ¹ s_j}. Длина последовательности s обозначается через len(s), а конкатенация последовательностей s и t обозначается st. Циклическим сдвигом s называется последовательность s¢s¢¢, где s = s¢¢s¢; она имеет вид s_i,..., s_N, s₁,..., s_i-1. Через CS(s) (cyclic shift - циклический сдвиг) обозначено множество циклических сдвигов s, и естественно |CS(s)| = len(s).

Говорят, что кольцо помечено последовательностью (s₁,..., s_N), если идентификаторы процессов с s₁ по s_N расположены на кольце (размера N) в таком порядке. Кольцо, помеченное s также называют s- кольцом. Если t - циклический сдвиг s, то t -кольцо совпадает с s- кольцом.

С каждым сообщением, посылаемым в алгоритме, свяжем последовательность идентификаторов процессов, называемую следом (trace) сообщения. Если сообщение m было послано процессом p до того, как p получил какое-либо сообщение, след m равен (p). Если m было послано процессом p после того, как он получил сообщение со следом s = (s₁,..., s_k), тогда след m равен (s₁,..., s_k, p). Сообщение со следом s называется s- сообщением. Нижняя граница будет выведена из свойств множества всех следов сообщений, которые могут быть посланы алгоритмом.

Пусть E - подмножество D. Множество E полно (exhaustive), если

(1) E префиксно замкнуто, т.е. tu Î E Þ t Î E; и

(2) E циклически покрывает D, т.е. " s Î D: CS(s) Ç E ¹ Æ.

Далее будет показано, что множество всех следов алгоритма полно. Для того, чтобы вывести из этого факта нижнюю границу сложности алгоритма, определены две меры множества E. Последовательность t является последовательной цепочкой идентификаторов в s-кольце, если t - префикс какого-либо r Î CS(s). Обозначим через M(s,E) количество последовательностей в E, которые удовлетворяют этому условию в s-кольце, а через M_k(s,E) - количество таких цепочек длины k;

M(s,E) = |{ t Î E: t - префикс некоторого r Î CS(s) }|  и

M_k(s,E) = |{ t Î E: t - префикс некоторого r Î CS(s) и len(t) = k}|.

В дальнейшем, допустим, что A - алгоритм, который вычисляет наименьший идентификатор, а E_A - множество последовательностей s таких, что s-сообщение посылается, когда алгоритм A выполняется на s -кольце.

Лемма 7.10 Если последовательности t и u содержат подстроку s и s- сообщение посылается, когда алгоритм A выполняется на t-кольце, то s-сообщение также посылается, когда A выполняется на u-кольце.

Доказательство. Посылка процессом s_k s-сообщения, где s = (s₁,..., s_k), каузально зависит только от процессов с s₁ по s_k. Их начальное состояние в u -кольце совпадает с состоянием в t -кольце (напоминаем, что размер кольца неизвестен), и следовательно совокупность событий, предшествующих посылке сообщения, также выполнима и в u -кольце.

Лемма 7.11 E_A - полное множество.

Доказательство. Чтобы показать, что E_A циклически замкнуто, заметим, что если A посылает s- сообщение при выполнении на s- кольце, тогда для любого префикса t последовательности s A сначала посылает t- сообщение на s- кольце. По Лемме 7.10 A посылает t- сообщение на t- кольце, следовательно t Î E_A.

Чтобы показать, что E_A циклически покрывает D, рассмотрим вычисление A на s- кольце. Хотя бы один процесс выбирает наименьший идентификатор, откуда следует (аналогично доказательству Теоремы 6.11), что этот процесс получил сообщение со следом длины len(s). Этот след является циклическим сдвигом s и принадлежит E.

Лемма 7.12 В вычислении на s- кольце алгоритм A посылает не менее M(s,E_A) сообщений.

Доказательство. Пусть t Î E_A - префикс циклического сдвига r последовательности s. Из определения E_A, A посылает t-сообщение в вычислении на t-кольце, а следовательно также и на r-кольце, которое совпадает с s-кольцом. Отсюда, для каждого t из {t Î E: t - префикс некоторого r Î CS(s)} в вычислении на s-кольце посылается хотя бы одно t-сообщение, что доказывает, что количество сообщений в таком вычислении составляет не менее M(s,E).

Для конечного множества I идентификаторов процессов обозначим через Per(I) множество всех перестановок I. Обозначим через ave_A(I) среднее количество сообщений, используемых A во всех кольцах, помеченных идентификаторами из I, а через wor_A(I) - количество сообщений в наихудшем случае. Из предыдущей леммы следует, что если I содержит N элементов, то

(1); и

(2).

 Теперь нижнюю границу можно вывести путем анализа произвольных полных множеств.

Теорема 7.13 Средняя сложность однонаправленного алгоритма поиска наименьшего идентификатора составляет не менее N* H _N.

Доказательство. Усредняя по всем начальным конфигурациям, помеченным множеством I, мы находим

 

Зафиксируем k и отметим, что для любого s Î Per(I) существует N префиксов циклических сдвигов s длины k. N! перестановок в Per(I) увеличивают количество таких префиксов до N*N!. Их можно сгруппировать в N*N!/k групп, каждая из которых содержит по k циклических сдвигов одной последовательности. Т.к. E_A циклически покрывает D, E_A пересекает каждую группу, следовательно.

Отсюда следует.

Этот результат означает, что алгоритм Чанга-Робертса оптимален, когда рассматривается средний случай. Сложность в наихудшем случае больше или равна сложности в среднем случае, откуда следует, что наилучшая достижимая сложность для наихудшего случая находится между N* H _N» 0.69N logN и» 0.356N logN.

Доказательство, данное в этом разделе, в значительной степени полагается на предположения о том, что кольцо однонаправленное и его размер неизвестен. Нижняя граница, равная 0.5N* H _N была доказана Bodlaender [Bod88] для средней сложности алгоритмов выбора на двунаправленных кольцах, где размер кольца неизвестен. Чтобы устранить недетерминизм из двунаправленного кольца, рассматриваются вычисления, в которых каждый процесс начинается в одно и то же время и все сообщения имеют одинаковую задержку передачи. Для случая, когда размер кольца известен, Bodlaender [Bod91a] вывел нижнюю границу, равную 0.5N logN для однонаправленных колец и (1/4-e)N* H _N для двунаправленных колец (обе границы для среднего случая).

В итоге оказывается, что сложность выбора на кольце не чувствительна практически ко всем предположениям. Независимо от того, известен или нет размер кольца, однонаправленное оно или двунаправленное, рассматривается ли средний или наихудший случай, - в любом случае сложность составляет Q(N logN). Существенно важно, что кольцо асинхронно; для сетей, где доступно глобальное время, сложность сообщений ниже, как будет показано в Главе 11.

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

Заключение 7.14 Любой децентрализованный волновой алгоритм для кольцевых сетей передает не менее W(N logN) сообщений, как в среднем, так и в наихудшем случае.

Рис.7. 8  

 

7.3 Произвольные Сети

Теперь изучим проблему выбора для сетей произвольной, неизвестной топологии без знания о соседях. Нижняя граница Ω(N logN+ ½ E ½) сообщений будет показана ниже. Доказательство объединяет идею Теоремы 6.6 и результаты предыдущего подраздела. В Подразделе 7.3.1 будет представлен простой алгоритм, который имеет низкую сложность по времени, но высокую сложность по сообщениям в худшем случае. В Подразделе 7.3.2 будет представлен оптимальный алгоритм для худшего случая.

Теорема 7.15 Любой сравнительный алгоритма выбора для произвольных сетей имеет (в худшем и среднем случае) сложность по сообщения по крайней мере Ω(Nlog N + ½ E ½).

 

Рисунок 7.8 вычисление с двумя ЛИДЕРАМИ.

 

Доказательство. Граница Ω(N log N + ½ E ½) является нижней, потому что произвольные сети включают кольца, для которых нижняя граница Ω(N logN). Чтобы видеть, что ½ E ½ сообщений является нижней границей, даже в лучшем из всех вычислений, предположим что, алгоритм выбора имеет вычисление С на сети G, в котором обменивается менее чем   ½ E ½ сообщений; см. Рисунок 7.8. Построим сеть G ', соединяя две копии G одним ребром между узлами, связанными ребром, которое не используется в C. Тождественные части сети имеют тот же самый относительный порядок как и в G. Вычисление С может моделироваться одновременно в обеих частях G ', выдавая вычисление, в котором два процесса станут избранными. o

                                                                               

Заключение 7.16 Децентрализованный волновой алгоритм для произвольных сетей без знания о соседях имеет сложность по сообщения по крайней мере Ω(NlogN + ½ E ½).

7.3.1 Вырождение и Быстрый Алгоритм

Алгоритм для выбора лидера может быть получен из произвольного централизованного волнового алгоритма применением преобразования называемого вырождением. В полученном алгоритме выбора каждый инициатор начинает отдельную волну; все сообщения волны, начатой процессом p должны быть помечены идентификатором p, чтобы отличить их от сообщений различных волн. Алгоритм гарантирует, что, независимо от того, сколько волн начато, только одна волна будет бежать к решению, а именно, волна самого маленького инициатора. Все другие волны будут прерваны прежде, чем решение может иметь место.

Для волнового алгоритма A, алгоритм выбора Ex(A) следующий. В каждый момент времени каждый процесс активен не более чем в одной волне; эта волна - текущая активная волна, обозначенная caw, с начальным значением udef. Инициаторы выбора действуют, как будто они начинают волну и присваивают caw их собственный идентификатор. Если сообщение некоторой волны, скажем волны, которую начал q, достигает p, p обрабатывает сообщение следующим образом.

 

var caw_p  : P       init udef; (* текущая активная волна *)

rec _p    : integer init 0; (* число полученных á tok, caw_p ñ  *)

father_p  : P       init udef; (* отец в волне caw_p *)

lrec_p  : integer init 0; (* число полученных á ldr,. ñ  *)

win_p: P        init udef; (* идентификатор лидера*)

begin if p is initiator then

        begin caw_p:= p;

                  forall q Î Neigh _p do send á tok, p ñ to q

        end;

     while lrec_p < #Neigh_p do

         begin receive msg from q;

                    if msg = á ldr, r ñ then

                       begin if lrec_p = 0 then

                                     forall q Î. Neigh_p do send á ldr, r ñ to q;

                                 lrec_p:= lrec_p + 1; win_p:= r

end

                    else (* сообщение á tok, r ñ  *)

                       begin if r < caw_p then (* Переинициализируем алгоритм*)

                                    begin caw_p:= r, rec_p:= 0, father_p:== q;

                                              forall sÎ Neigh_p, s ¹ q

                                                        do send á tok, r ñ to s

                                     end;

                                 if r = caw_p then

begin rec_p:= rec _p + 1;

          if rec_p = #Neigh_p then

             if caw_p = p

                then forall s Î Neigh_p do send á ldr, p ñ to s

                else send á tok, cawp ñ to father_p

end

(* если r > caw_p  сообщение игнорируется*)

  end

 end;

Предыдущая6789101112131415161718192021Следующая

Поделиться:

Воспользуйтесь поиском по сайту: