МЕНЮ


Фестивали и конкурсы
Семинары
Издания
О МОДНТ
Приглашения
Поздравляем

НАУЧНЫЕ РАБОТЫ


  • Инновационный менеджмент
  • Инвестиции
  • ИГП
  • Земельное право
  • Журналистика
  • Жилищное право
  • Радиоэлектроника
  • Психология
  • Программирование и комп-ры
  • Предпринимательство
  • Право
  • Политология
  • Полиграфия
  • Педагогика
  • Оккультизм и уфология
  • Начертательная геометрия
  • Бухучет управленчучет
  • Биология
  • Бизнес-план
  • Безопасность жизнедеятельности
  • Банковское дело
  • АХД экпред финансы предприятий
  • Аудит
  • Ветеринария
  • Валютные отношения
  • Бухгалтерский учет и аудит
  • Ботаника и сельское хозяйство
  • Биржевое дело
  • Банковское дело
  • Астрономия
  • Архитектура
  • Арбитражный процесс
  • Безопасность жизнедеятельности
  • Административное право
  • Авиация и космонавтика
  • Кулинария
  • Наука и техника
  • Криминология
  • Криминалистика
  • Косметология
  • Коммуникации и связь
  • Кибернетика
  • Исторические личности
  • Информатика
  • Инвестиции
  • по Зоология
  • Журналистика
  • Карта сайта
  • Распределенные алгоритмы

    R2. Не-инициатор передает маркер своему родителю (соседу, от которого он

    впервые получил маркер), только если невозможна передача по другим каналам,

    в соответствии с правилом R1.

    var usedp[q] : boolean init false для всех q ? Neighp ;

    (* Признак того, отправил ли p сообщение q *)

    fatherp : process init udef ;

    Для инициатора (выполняется один раз):

    begin fatherp := p ; выбор q ? Neighp ;

    usedp[q] := true ; send to q ;

    end

    Для каждого процесса при получении от q0:

    begin if fatherp = udef then fatherp := q0 ;

    if ?q ? Neighp : usedp[q]

    then decide

    else if ?q ? Neighp : (q ? fatherp & ¬usedp[q])

    then begin выбор q ? Neighp \ {fatherp} с ¬usedp[q] ;

    usedp[q] := true ; send to q

    end

    else begin usedp[fatherp] := true ;

    send to fatherp

    end

    end

    Алгоритм 6.13 Алгоритм обхода Тарри.

    Теорема 6.29 Алгоритм Тарри (Алгоритм 6.13) является алгоритмом обхода.

    Доказательство. Т.к. маркер передается не более одного раза в обоих

    направлениях через каждый канал, всего он передается не более 2|E| раз до

    завершения алгоритма. Т.к. каждый процесс передает маркер через каждый

    канал не более одного раза, то каждый процесс получает маркер через каждый

    канал не более одного раза. Каждый раз, когда маркер захватывается не-

    инициатором p, получается, что процесс p получил маркер на один раз больше,

    чем послал его. Отсюда следует, что количество каналов, инцидентных p,

    превышает количество каналов, использованных p, по крайней мере, на 1.

    Таким образом, p не принимает решение, а передает маркер дальше.

    Следовательно, решение принимается в инициаторе.

    Далее, за 3 шага будет доказано, что когда алгоритм завершается, каждый

    процесс передал маркер.

    Все каналы, инцидентные инициатору, были пройдены один раз в обоих

    направлениях. Инициатором маркер был послан по всем каналам, иначе алгоритм

    не завершился бы. Инициатор получил маркер ровно столько же раз, сколько

    отправил его; т.к. инициатор получал маркер каждый раз через другой канал,

    то маркер пересылался через каждый канал по одному разу.

    Для каждого посещаемого процесса p все каналы, инцидентные p были пройдены

    один раз в каждом направлении. Предположив, что это не так, выберем в

    качестве p первый встретившийся процесс, для которого это не выполняется, и

    заметим, что из пункта (1) p не является инициатором. Из выбора p, все

    каналы, инцидентные fatherp были пройдены один раз в обоих направлениях,

    откуда следует, что p переслал маркер своему родителю. Следовательно, p

    использовал все инцидентные каналы, чтобы переслать маркер; но, т.к. маркер

    в конце остается в инициаторе, p получил маркер ровно столько же раз,

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

    инцидентный канал. Мы пришли к противоречию.

    Все процессы были посещены и каждый канал был пройден по одному разу в

    обоих направлениях. Если есть непосещенные процессы, то существуют соседи p

    и q такие, что p был посещен, а q не был. Это противоречит тому, что все

    каналы p были пройдены в обоих направлениях. Следовательно, из пункта (2),

    все процессы были посещены и все каналы пройдены один раз в обоих

    направлениях.

    Каждое вычисление алгоритма Тарри определяет остовное дерево сети, как

    показано в Лемме 6.3. В корне дерева находится инициатор, а каждый не-

    инициатор p в конце вычисления занес своего родителя в дереве в переменную

    fatherp. Желательно, чтобы каждый процесс также знал (в конце вычисления),

    какие из его соседей являются его сыновьями в дереве. Этого можно

    достигнуть, посылая родителю fatherp специальное сообщение.

    6.4 Временная сложность: поиск в глубину

    Процессы в алгоритме Тарри достаточно свободны в выборе соседа, которому

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

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

    остовные деревья с дополнительным свойством: каждое листовое ребро

    соединяет две вершины, одна из которых является предком другой. Листовое

    ребро - это ребро, не принадлежащее остовному дереву. В данном корневом

    остовном дереве T сети G для каждого p T[p] обозначает множество процессов

    в поддереве p, а A[p] обозначает предков p, т.е. вершины на пути в T от

    корня до p. Заметим, что q ? T[p] ? p ? A[q].

    Определение 6.30 Остовное дерево T сети G называется деревом поиска в

    глубину, если для каждого листового ребра pq q ? T[p] ? q ? A[p].

    Деревья поиска в глубину, или DFS-деревья (DFS - Depth-First Search),

    используются во многих алгоритмах на графах, таких как проверка

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

    маркировки (см. Подраздел 4.4.2). В Разделе 6.4.1 будет показано, что

    незначительная модификация алгоритма Тарри (а именно, ограничение свободы

    выбора процессов) позволяет алгоритму вычислять деревья поиска в глубину.

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

    глубину. В Подразделе 6.4.2 будут представлены два алгоритма, которые

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

    алгоритм. Понятие временной сложности распределенных алгоритмов будет

    определено ниже. В Подразделе 6.4.3 будет представлен алгоритм поиска в

    глубину для сетей с начальным знанием идентификации соседей. В этом случае

    Теорема 6.6 неприменима, и фактически может быть дан алгоритм, использующий

    только 2N-2 сообщений.

    Временная сложность распределенных алгоритмов. Исключительно в целях

    анализа распределенных алгоритмов, будут сделаны некоторые идеализированные

    временные предположения. Корректность алгоритмов никак не зависит от этих

    предположений.

    Определение 6.31 Временная сложность распределенного алгоритма - это

    максимальное время, требуемое на вычисление алгоритма при следующих

    предположениях:

    T1. Процесс может выполнить любое конечное количество событий за нулевое

    время.

    T2. Промежуток времени между отправлением и получением сообщения - не более

    одной единицы времени.

    Временные сложности всех волновых алгоритмов этой главы изложены в Таблице

    6.19. Проверка величин из этой таблицы, не доказанных в этой главе,

    оставлена читателю в качестве упражнения. Альтернативные определения

    временной сложности обсуждаются в Подразделе 6.5.3.

    Лемма 6.32 Для алгоритмов обхода временная сложность равна сложности

    сообщений.

    Доказательство. Сообщения пересылаются последовательно, и каждое может

    занять одну единицу времени.

    6.4.1 Распределенный поиск в глубину

    Классический алгоритм поиска в глубину получается, когда свобода выбора

    соседа для передачи маркера в алгоритме Тарри ограничивается следующим,

    третьим правилом; см. Алгоритм 6.14.

    R3. Когда процесс получает маркер, он отправляет его обратно через тот же

    самый канал, если это позволяется правилами R1 и R2.

    Теорема 6.33 Классический алгоритм поиска в глубину (Алгоритм 6.14)

    вычисляет остовное дерево поиска в глубину, используя 2|E| сообщений и 2|E|

    единиц времени.

    Доказательство. Т.к. алгоритм реализует алгоритм Тарри, это алгоритм обхода

    и он вычисляет остовное дерево T. Уже было показано, что каждый канал

    передает два сообщения (по одному в обоих направлениях), что доказывает

    оценку сложности сообщений, а оценка для временной сложности следует из

    того, что 2|E| сообщений передаются одно за другим, причем каждое занимает

    не более одной единицы времени. Остается показать, что из правила R3

    следует, что получающееся дерево - дерево поиска в глубину.

    Во-первых, из R3 следует, что за первым проходом по листовому ребру

    немедленно следует второй, в обратном направлении. Пусть pq - листовое

    ребро и p первым использует ребро. Когда q получает маркер от p, q уже

    посещен (иначе q присвоит fatherq p и ребро не будет листовым) и usedp[q] =

    false (т.к. по предположению p первый из двух процессов использовал ребро).

    Следовательно, по правилу R3, q немедленно отправляет маркер обратно p.

    Теперь можно показать, что если pq - листовое ребро, используемое сначала

    p, то q ? A[p]. Рассмотрим путь, пройденный маркером, пока он не был

    переслан через pq. Т.к. pq - листовое ребро, q был посещен до того, как

    маркер попал в q через это ребро:

    ..., q, ..., p, q

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

    r1, r2, r1, где r1r2 - листовое ребро, на r1. Из предыдущих наблюдений, все

    листовые ребра теперь убраны, откуда следует, что получившийся путь - это

    путь в T, состоящий только из ребер, пройденных до первого прохождения pq.

    Если q не является предком p, то отсюда следует, что ребро от q до fatherq

    было пройдено до того, как было пройдено ребро qp, что противоречит правилу

    R2 алгоритма.

    var usedp[q] : boolean init false для всех q ? Neighp ;

    (* Признак того, отправил ли p сообщение q *)

    fatherp : process init udef ;

    Для инициатора (выполняется один раз):

    begin fatherp := p ; выбор q ? Neighp ;

    usedp[q] := true ; send to q ;

    end

    Для каждого процесса при получении от q0:

    begin if fatherp = udef then fatherp := q0 ;

    if ?q ? Neighp : usedp[q]

    then decide

    else if ?q ? Neighp : (q ? fatherp & ¬usedp[q])

    then begin if fatherp ? q0 & ¬usedp[q0]

    then q := q0

    else выбор q ? Neighp \ {fatherp}

    с ¬usedp[q] ;

    usedp[q] := true ; send to q

    end

    else begin usedp[fatherp] := true ;

    send to fatherp

    end

    end

    Алгоритм 6.14 Классический алгоритм поиска в глубину.

    Сложность сообщений классического распределенного поиска в глубину равна

    2|E|, по Теореме 6.6 это наилучшая сложность (за исключением множителя 2),

    если идентификация соседей не известна изначально. Временная сложность

    также составляет 2|E|, что по Лемме 6.32, является наилучшей сложностью для

    алгоритмов обхода в этом случае. Распределенная версия поиска в глубину

    была впервые представлена Cheung [Che83].

    В Подразделе 6.4.2 будут рассмотрены два алгоритма, которые строят дерево

    поиска в глубину в сети без знания идентификации соседей за O(N) единиц

    времени. Следовательно, эти алгоритмы не являются алгоритмами обхода. В

    Подразделе 6.4.3 знание о соседях будет использовано для получения

    алгоритма с временной сложностью и сложностью сообщений O(N).

    6.4.2 Алгоритмы поиска в глубину за линейное время

    Причина высокой временной сложности классического алгоритма поиска в

    глубину состоит в том, что все ребра, как принадлежащие дереву, так и

    листовые, обходятся последовательно. Сообщение-маркер проходит по

    всем листовым ребрам и немедленно возвращается обратно, как показано в

    доказательстве Теоремы 6.33. Все решения с меньшей временной сложностью

    основаны на том, что маркер проходит только по ребрам дерева. Очевидно, на

    это потребуется линейное время, т.к. существует только N-1 ребро дерева.

    Решение Авербаха. В алгоритм включается механизм, который предотвращает

    передачу маркера через листовое ребро. В алгоритме Авербаха [Awerbuch;

    Awe85b] гарантируется, что каждый процесс в момент, когда он должен

    передать маркер, знает, какие из его соседей уже были пройдены. Затем

    процесс выбирает непройденного соседа, или, если такого не существует,

    посылает маркер своему родителю.

    Когда процесс p впервые посещается маркером (для инициатора это происходит

    в начале алгоритма), p сообщает об этом всем соседям r, кроме его родителя,

    посылая сообщения . Передача маркера откладывается, пока p не получит

    сообщения от всех соседей. При этом гарантируется, что каждый сосед r

    процесса p в момент, когда p передает маркер, знает, что p был посещен.

    Когда позже маркер прибывает в r, r не передаст маркер p, если только p не

    его родитель; см. Алгоритм 6.15.

    Из-за передачи сообщений в большинстве случаев usedp[fatherp] = true,

    даже если p еще не послал маркер своему родителю. Поэтому в алгоритме

    должно быть явно запрограммировано, что только инициатор может принимать

    решения; а не-инициатор p, для которого usedp[q] = true для всех соседей q,

    передает маркер своему родителю.

    Теорема 6.34 Алгоритм Авербаха (Алгоритм 6.15) вычисляет дерево поиска в

    глубину за 4N-2 единиц времени и использует 4|E| сообщений.

    Доказательство. По существу, маркер передается по тем же самым каналам, как

    и в Алгоритме 6.14, за исключением того, что пропускается передача по

    листовым каналам. Т.к. передача по листовым каналам не влияет на конечное

    значение fatherp для любого процесса p, то в результате всегда получается

    дерево, которое может получиться и в Алгоритме 6.14.

    Маркер последовательно проходит дважды через каждый из N-1 каналов дерева,

    на что тратится 2N-2 единиц времени. В каждой вершине маркер простаивает

    перед тем, как быть переданным, не более одного раза из-за обмена

    сообщениями /, что приводит к задержке не более чем на 2 единицы

    времени в каждой вершине.

    Каждое листовое ребро передает два сообщения и два сообщения .

    Каждое ребро в дереве передает два сообщения , одно (посылаемое

    от родителя потомку), и одно (от потомка родителю). Следовательно,

    передается 4|E| сообщений.

    var usedp[q] : boolean init false для всех q ? Neighp ;

    (* Признак того, отправил ли p сообщение q *)

    fatherp : process init udef ;

    Для инициатора (выполняется один раз):

    begin fatherp := p ; выбор q ? Neighp ;

    forall r ? Neighp do send to r ;

    forall r ? Neighp do receive from r ;

    usedp[q] := true ; send to q ;

    end

    Для каждого процесса при получении от q0:

    begin if fatherp = udef then

    begin fatherp := q0 ;

    forall r ? Neighp\ {fatherp} do send to r ;

    forall r ? Neighp\ {fatherp} do receive from r ;

    end ;

    if p - инициатор and ?q ? Neighp : usedp[q]

    then decide

    else if ?q ? Neighp : (q ? fatherp & ¬usedp[q])

    then begin if fatherp ? q0 & ¬usedp[q0]

    then q := q0

    else выбор q ? Neighp \ {fatherp}

    с ¬usedp[q] ;

    usedp[q] := true ; send to q

    end

    else begin usedp[fatherp] := true ;

    send to fatherp

    end

    end

    Для каждого процесса при получении от q0:

    begin usedp[q0] := true ; send to q0 end

    Алгоритм 6.15 Алгоритм поиска в глубину Авербаха.

    Передачу сообщения соседу, которому процесс передает маркер, можно

    опустить. Это усовершенствование (не выполняемое в Алгоритме 6.15)

    сберегает по два сообщения для каждого ребра дерева и, следовательно,

    уменьшает сложность сообщений на 2N-2 сообщения.

    Решение Сайдона. Алгоритм Сайдона [Cidon; Cid88] улучшает временную

    сложность алгоритма Авербаха, не посылая сообщения . В модификации

    Сайдона маркер передается немедленно, т.е. без задержки на 2 единицы

    времени, внесенной в алгоритм Авербаха ожиданием подтверждения. Этот же

    алгоритм был предложен Лакшмананом и др. [Lakshmanan; LMT87]. В алгоритме

    Сайдона может возникнуть следующая ситуация. Процесс p получил маркер и

    послал сообщение своему соседу r. Маркер позже попадает в r, но в

    момент, когда r получает маркер, сообщение процесса p еще не достигло

    r. В этом случае r может передать маркер p, фактически посылая его через

    листовое ребро. (Заметим, что сообщения в алгоритме Авербаха

    предотвращают возникновение такой ситуации.)

    Чтобы обойти эту ситуацию процесс p запоминает (в переменной mrsp), какому

    соседу он переслал маркер в последний раз. Когда маркер проходит только по

    ребрам дерева, p получает его в следующий раз от того же соседа mrsp. В

    ситуации, описанной выше, p получает сообщение от другого соседа, а

    именно, от r; в этом случае маркер игнорируется, но p помечает ребро rp,

    как пройденное, как если бы от r было получено сообщение . Процесс r

    получает сообщение от p после пересылки маркера p, т.е. r получает

    сообщение от соседа mrsr. В этом случае r действует так, как если бы

    он еще не послал маркер p; r выбирает следующего соседа и передает маркер;

    см. Алгоритм 6.16/6.17.

    Теорема 6.35 Алгоритм Сайдона (Алгоритм 6.16/6.17) вычисляет DFS-дерево за

    2N-2 единиц времени, используя 4|E| сообщений.

    Доказательство. Маршрут маркера подобен маршруту в Алгоритме 6.14.

    Прохождение по листовым ребрам либо пропускается (как в Алгоритме 6.15),

    либо в ответ на маркер через листовое ребро посылается сообщение . В

    последнем случае, процесс, получая сообщение , продолжает передавать

    маркер, как если бы маркер был возвращен через листовое ребро немедленно.

    Время между двумя успешными передачами маркера по дереву ограничено одной

    единицей времени. Если маркер послали по ребру дерева процессу p в момент

    времени t, то в момент t все сообщения ранее посещенных соседей q

    процесса p были посланы, и, следовательно, эти сообщения прибудут не

    позднее момента времени t+1. Итак, хотя p мог несколько раз послать маркер

    по листовым ребрам до t+1, не позднее t+1 p восстановился после всех этих

    ошибок и передал маркер по ребру, принадлежащему дереву. Т.к. должны быть

    пройдены 2N-2 ребра дерева, алгоритм завершается за 2N-2 единиц времени.

    Через каждый канал передается не более двух сообщений и двух ,

    откуда граница сложности сообщений равна 4|E|.

    var usedp[q] : boolean init false для всех q ? Neighp ;

    fatherp : process init udef ;

    mrsp : process init udef ;

    Для инициатора (выполняется один раз):

    begin fatherp := p ; выбор q ? Neighp ;

    forall r ? Neighp do send to r ;

    usedp[q] := true ; mrsp := q ; send to q ;

    end

    Для каждого процесса при получении от q0:

    begin usedp[q0] := true ;

    Страницы: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36


    Приглашения

    09.12.2013 - 16.12.2013

    Международный конкурс хореографического искусства в рамках Международного фестиваля искусств «РОЖДЕСТВЕНСКАЯ АНДОРРА»

    09.12.2013 - 16.12.2013

    Международный конкурс хорового искусства в АНДОРРЕ «РОЖДЕСТВЕНСКАЯ АНДОРРА»




    Copyright © 2012 г.
    При использовании материалов - ссылка на сайт обязательна.