Распределенные алгоритмы

Пролог                                                                                                                             6

1 Введение: распределенные системы                                                  7

1.1 Что такое распределенная система?                                                                       7

1.1.1 Мотивация                                                                                                              8

1.1.2 Компьютерные сети                                                                                             10

1.1.3 Глобальные сети                                                                                                   11

1.1.4 Локальные сети                                                                                                    13

1.1.5 Многопроцессорные компьютеры                                                                     16

1.1.6 Взаимодействующие процессы                                                                          19

1.2 Архитектура и Языки                                                                                              22

1.2.1 Архитектура                                                                                                          22

1.2.2 Ссылочная Модель 
OSI                                                                                      24

1.2.3 OSI Модель в  локальных
сетях: IEEE Стандарты                                           26

1.2.4 Поддержка Языка                                                                                                 27

1.3 Распределенные
Алгоритмы                                                                                  29

1.3.1 Распределенный
против Централизованных Алгоритмов                             30

1.3.2 Пример: Связь с 
одиночным сообщением                                                        32

1.3.3 Область исследования                                                                                         37

1.3.4 Иерархическая
структура книги                                                                         37

2 Модель                                                                                                                       40

2.1 Системы перехода и алгоритмы                                                                            41

2.1.1 Системы переходов                                                                                              42

2.1.2 Системы с асинхронной передачей сообщений                                               43

2.1.3 Системы с синхронной передачей сообщений                                                 45

2.1.4 Справедливость                                                                                                    47

2.2 Доказательство свойств систем перехода                                                            47

2.2.1 Свойства безопасности                                                                                        48

2.2.2 Свойства живости                                                                                                50

2.3 Каузальный порядок событий и логические часы                                            51

2.3.1 Независимость и зависимость событий                                                             52

2.3.2 Эквивалентность исполнений: вычисления                                                     54

2.3.3 Логические часы                                                                                                  57

2.4 Дополнительные допущения, сложность                                                            60

2.4.2 Свойства каналов                                                                                                 62

2.4.3 Допущения реального времени                                                                          64

2.4.4 Знания процессов                                                                                                 64

2.4.5 Сложность распределенных алгоритмов                                                           66

3 Протоколы Связи                                                                                              66

3.1 Сбалансированный протокол скользящего окна                                              68

3.1.1 Представление протокола                                                                                   68

3.1.2 Доказательство правильности протокола                                                          71

3.1.3 Обсуждение протокола                                                                                        73

3.2 Протокол, основанный на таймере                                                                       75

3.2.1 Представление Протокола                                                                                  78

3.2.2 Доказательство корректности
протокола                                                          81

3.2.3 Обсуждение протокола                                                                                        85

Упражнения к главе 3                                                                                                    88

Раздел 3.1                                                                                                                        88

Раздел 3.2                                                                                                                        89

4 Алгоритмы маршрутизации                                                                       89

4.1 Адресат-основанная маршрутизация                                                                   91

4.2 Проблема кротчайших путей всех пар                                                                 95

4.2.1 Алгоритм Флойда-Уошала                                                                                  95

4.2.2 Алгоритм кротчайшего пути.(Toueg)                                                                 98

4.2.3 Обсуждение и Дополнительные Алгоритмы                                                  102

4.3 Алгоритм Netchange                                                                                               106

4.3.1 Описание алгоритма                                                                                          107

4.3.2 Корректность алгоритма Netchange                                                                 112

4.3.3 Обсуждение алгоритма                                                                                      113

4.4 Маршрутизация с Компактными Таблицами маршрутизации                    114

4.4.1 Схема разметки деревьев                                                                                   115

4.4.2 Интервальная маршрутизация                                                                          118

4.4.3 Префиксная маршрутизация                                                                             125

4.5 Иерархическая маршрутизация                                                                          127

4.5.1 Уменьшение количества решений маршрутизации                                       128

Упражнения к Части 4                                                                                                 130

Раздел 4.1                                                                                                                      130

Раздел 4.2                                                                                                                      131

Раздел 4.3                                                                                                                      131

Раздел 4.4                                                                                                                      131

Раздел 4.5                                                                                                                      132

5 Беступиковая коммутация пакетов                                                 132

5.1 Введение                                                                                                                   133

5.2 Структурированные решения                                                                             134

5.2.1 Буферные Графы                                                                                                135

5.2.2 Ориентации G                                                                                                    138

5.3 Неструктурированные решения                                                                          141

5.3.1 Контроллеры с прямым и обратным счетом                                                   141

5.3.2 Контроллеры с опережающим и отстающим состоянием                             142

5.4 Дальнейшие проблемы                                                                                          144

5.4.1 Топологические изменения                                                                               145

5.4.2 Другие виды тупиков                                                                                        146

5.4.3 Лайфлок (livelock)                                                                                               147

Упражнения к Главе 5                                                                                                 149

Раздел 5.1                                                                                                                      149

Раздел 5.2                                                                                                                      149

Раздел 5.3                                                                                                                      149

6 Волновые алгоритмы и алгоритмы обхода                                149

6.1  Определение и использование волновых алгоритмов                                   150

6.1.1  Определение волновых алгоритмов                                                               151

6.1.2  Элементарные результаты о волновых алгоритмах                                      153

6.1.3  Распространение информации с обратной связью                                        155

6.1.4  Синхронизация                                                                                                  156

6.1.5  Вычисление функций инфимума                                                                    156

6.2  Волновые алгоритмы                                                                                           158

6.2.1  Кольцевой алгоритм                                                                                         158

6.2.2  Древовидный алгоритм                                                                                    159

6.2.3  Эхо-алгоритм                                                                                                     161

6.2.4  Алгоритм опроса                                                                                               163

6.2.5  Фазовый алгоритм                                                                                            164

6.2.6  Алгоритм Финна                                                                                               167

6.3  Алгоритмы обхода                                                                                                 169

6.3.1  Обход клик                                                                                                         170

6.3.2  Обход торов                                                                                                       171

6.3.3  Обход гиперкубов                                                                                             172

6.3.4  Обход связных сетей                                                                                         173

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

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

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

6.4.3  Поиск в глубину со знанием соседей                                                             182

6.5  Остальные вопросы                                                                                              182

6.5.1  Обзор волновых алгоритмов                                                                           182

6.5.2  Вычисление сумм                                                                                              184

6.5.3  Альтернативные определения временной сложности                                  186

Упражнения к  Главе 6                                                                                                188

Раздел 6.1                                                                                                                      188

Раздел 6.2                                                                                                                      189

Раздел 6.3                                                                                                                      190

Раздел 6.4                                                                                                                      190

Раздел 6.5                                                                                                                      190

7  Алгоритмы выбора                                                                                       190

7.1  Введение                                                                                                                  191

7.1.1  Предположения, используемые в этой главе                                                 192

7.1.2  Выбор и волны                                                                                                  193

7.2  Кольцевые сети                                                                                                      196

7.2.1  Алгоритмы ЛеЛанна и Чанга-Робертса                                                          196

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

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

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

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

7.3.2 Алгоритм
Gallager-Humblet-Spira                                                                     210

7.3.3 Глобальное Описание
GHS Алгоритма.                                                          212

7.3.4 Детальное описания
GHS алгоритма                                                               215

7.3.5 Обсуждения и
Варианты GHS Алгоритма                                                      219

7.4 Алгоритм
Korach-Kutten-Moran                                                                          220

7.4.1 Модульное
Строительство                                                                                221

7.4.2 Применения Алгоритма
KKM                                                                          225

Упражнения к  Главе 7                                                                                                225

Раздел 7.1                                                                                                                      225

Раздел 7.2                                                                                                                      226

Раздел 7.3                                                                                                                      226

Раздел 7.4                                                                                                                      226

8 Обнаружение завершения                                                                        227

8.1 Предварительные
замечания                                                                               228

8.1.1 Определения                                                                                                       228

8.1.2 Две нижних границы                                                                                         231

8.1.3 Завершение Процессов                                                                                      233

8.2.2 Алгоритм
Shavit-Francez                                                                                    237

8.3 Решения, основанные на
волнах                                                                         241

8.3.1 Алгоритм
Dijkstra-Feijen-Van Gasteren                                                             242

8.3.2 Подсчет Основных Сообщений:
Алгоритм Сафра                                        245

8.3.3 Использование
Подтверждений                                                                       249

8.3.4 Обнаружение
завершения с помощью волн                                                    252

8.4 Другие Решения                                                                                                      254

8.4.1 Алгоритм
восстановления кредита                                                                  254

8.4.2 Решения,
использующие временные пометки                                                256

Упражнения к  Главе 8                                                                                                259

Раздел 8.1                                                                                                                      259

Раздел 8.2                                                                                                                      259

Раздел 8.3                                                                                                                      259

Раздел 8.4                                                                                                                      260

13 Отказоустойчивость в Асинхронных Системах                  260

13.1 Невозможность согласия                                                                                     260

13.1.1 Обозначения, Определения, Элементарные Результаты                             260

13.1.2 Доказательство невозможности                                                                      262

13.1.3 Обсуждение                                                                                                      264

13.2 Изначально-мертвые Процессы                                                                        265

13.3 Детерминированно Достижимые Случаи                                                        268

13.3.1 Разрешимая Проблема: Переименование                                                      269

13.3.2 Расширение Результатов Невозможности                                                     273

13.4 Вероятностные
Алгоритмы Согласия                                                             275

13.4.1 Аварийно-устойчивые Протоколы Согласия                                               276

13.4.2 Византийско-устойчивые Протоколы Согласия                                          280

13.5 Слабое Завершение                                                                                              285

Упражнения к Главе 13                                                                                               289

Раздел 13.1                                                                                                                    289

Раздел 13.2                                                                                                                    289

Раздел 13.3                                                                                                                    289

Раздел 13.4                                                                                                                    290

Раздел 13.5                                                                                                                    291

14 Отказоустойчивость в Синхронных Системах                     291

14.1 Синхронные Протоколы Решения                                                                    292

14.1.1 Граница Способности восстановления                                                         293

14.1.2 Алгоритм Византийского вещания                                                                295

14.1.3 Полиномиальный Алгоритм Вещания                                                          298

14.2 Протоколы с Установлением Подлинности                                                    303

14.2.1 Протокол Высокой Степени Восстановления                                              304

14.2.2 Реализация Цифровых Подписей                                                                   307

14.2.3 Схема Подписи ЭльГамаля                                                                             308

14.2.4 Схема Подписи RSA                                                                                        310

14.2.5 Схема Подписи Фиата-Шамира                                                                     310

14.2.6 Резюме и Обсуждение                                                                                     313

14.3 Синхронизация Часов                                                                                          315

14.3.1 Чтение Удаленных Часов                                                                                316

14.3.2 Распределенная Синхронизация Часов                                                         318

Пролог

Распределенные
системы и обработка распределенной информации получили значительное внимание в
последние несколько лет, и почти каждый университет предлагает, по крайней
мере, один курс по разработке распределенных алгоритмов. Существует большое
число книг о принципах распределенных систем; см. например Tanenbaum [Tan88]
или Sloman and Kramer [SK87], хотя они концентрируются в основном на
архитектурных аспектах, а не на алгоритмах.

Было замечено, что алгоритмы – это основа любого
применения компьютеров. Поэтому кажется оправданным посвятить эту книгу
полностью распределенным алгоритмам. Эта книга направлена на то, чтобы
представить большую часть теории распределенных алгоритмов, которые развивались
в течение последних 15 лет.  Эта книга может быть использована как учебник для
одно- или двух-семестрового курса по распределенным алгоритмам. Преподаватель
одно-семестрового курса может выбирать темы по своему усмотрению.

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

Упражнения. 
Каждая глава (за исключением глав 1 и 12) оканчивается списком упражнений и маленьких
проектов. Проекты обычно требуют, чтобы читатель разработал маленькое, но
нетривиальное расширение или практическое решение по материалу главы, и в
большинстве случаев у автора нет решения. Если читатель добьется успеха в
разработке этих маленьких проектов, то мне бы хотелось иметь копию результата.

Список ответов
(иногда частичных) у большинству упражнений доступен для преподавателей. Он
может быть получен у автора или по анонимному ftp.

Исправления
и предложения. Если читатель найдет ошибки и пропуски в этой книге, то
пусть информирует автора (предпочтительно по электронной почте). Вся
конструктивная критика, включая предложения по упражнения, очень
приветствуется.

1 Введение: распределенные системы

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

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

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

Однако сейчас
существует много превосходных книг по распределенным системам, касающихся архитектурных
и языковых аспектов. Смотрите Tanenbaum [Tan88], Sloman and Kramer [SK87], Bal
[Bal90], Coulouris [CD88], Goscinski [Gos91]. Как уже говорилось, настоящий
труд делает упор на алгоритмы распределенных систем. Раздел 1.3 объясняет,
почему разработка распределенных алгоритмов отличается от разработки
централизованных алгоритмов, там также делается краткий обзор текущего
состояния дел в исследованиях и дается описание остальной части книги.

1.1 Что такое распределенная система?

В этой главе мы
будем использовать термин «распределенная система», подразумевая взаимосвязанный
набор автономных компьютеров, процессов или процессоров. Компьютеры, процессы
или процессоры упоминаются как узлы распределенной системы. (В последующих
главах мы будем использовать более техническое понятие, см. определение 2.6.)
Будучи определенными как «автономные», узлы должны быть, по крайней мере,
оборудованы своим собственным блоком управления. Таким образом, параллельный компьютер
с одним потоком управления и несколькими потоками данных (SIMD) не подпадает
под определение распределенной системы. Чтобы быть определенными как «взаимосвязанными»,
узлы должны иметь возможность обмениваться информацией.

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

Более
ограничивающие определения распределенных систем могут быть также найдены в
литературе. Tanenbaum [Tan88], например, называет систему распределенной,
только если существуют автономные узлы прозрачные для пользователей системы.
Система распределенная в этом смысле ведет себя как виртуальная самостоятельная
компьютерная система, но реализация этой прозрачности требует разработки
замысловатых алгоритмов распределенного управления.

1.1.1 Мотивация

Распределенные
компьютерные системы могут получить предпочтение среди ряда систем или их использования
бывает просто не избежать, в силу многих причин, некоторые из которых
обсуждаются ниже. Этот список не исчерпывающий. Выбор распределенной системы
может быть мотивирован более чем одним аргументов приведенным ниже. И некоторые
из преимуществ могут быть получены как полезный побочный эффект при выборе
других причин. Характеристики распределенных систем могут также варьироваться,
в зависимости от причины их существования, но об этом мы поговорим более
детально в разделах с 1.1.2 по 1.1.6.

(1)  Обмен
информацией. Необходимость обмена данными между различными компьютерами
возросла в шестидесятых, когда большинство основных университетов и компаний
начали пользоваться своими собственными майнфреймами. Взаимодействие между
людьми из различных организаций облегчилось благодаря обмену данными между
компьютерами этих организаций, и это дало рост развитию так называемых глобальных
сетей (WAN). Компьютерная система соединенная в глобальную сеть обычно
снабжалась всем что необходимо пользователю: резервными хранилищами данных,
дисками, многими прикладными программами и принтерами.
            Позже компьютеры стали меньше и дешевле, и сегодня одна организация
может иметь множество компьютеров, иногда даже один компьютер на одного
работника (рабочую станцию). В этом случае также требуется чтобы эти компьютеры
были соединены для электронного обмена информацией между персоналом компании.

(2)  Разделение
ресурсов. Хотя с приходом более дешевых компьютеров стало возможно снабжать
каждого сотрудника организации личным компьютером, это же нельзя сделать для
периферии (принтеры, резервные хранилища, блоки дисков). В этом меньшем
масштабе каждый компьютер может положиться на специальные серверы, которые
снабжают его компиляторами и другими прикладными программами. Также, памяти
любого компьютера обычно недостаточно, чтобы хранить большой набор прикладных
программ, требуемых для каждого пользователя. Кроме того, компьютеры могут
использовать специальные узлы для служб печати и хранения данных. Сеть, соединяющая
компьютеры в масштабе предприятия называется локальной вычислительной сетью(LAN).
      Причины, по которым организация устанавливает сеть небольших компьютеров,
а не майнфреймы – снижение стоимости и расширяемость. Во-первых, меньшие
компьютеры имеют лучше соотношение цена-производительность, чем большие
компьютеры. Типичный майнфрейм может совершать операции в 50 раз быстрее, чем
персональный компьютер, но иметь стоимость в 500 раз большую. Во-вторых, если 
мощности системы больше не достаточно, то сеть может быть расширена добавлением
других машин (файловых серверов, принтеров и рабочих станций). Если мощность
монолитной системы больше неудовлетворительна, остается только полная замена.

(3)  Большая
надежность благодаря репликации. Распределенные системы имеют потенциал
надежности больший, чем монолитные системы благодаря свойству их частичного
выхода из строя. Это значит, что некоторые узлы системы могут выйти из строя, в
то время как другие по прежнему функционируют и могут взять на себя задачи
испорченных компонентов. Выход из строя монолитного компьютера действует на всю
систему целиком и нет возможности продолжать вычисления в этом случае. По этой
причине распределенные архитектуры представляют интерес при разработке высоко надежных
компьютерных систем.
        Высоко надежная система обычно состоит из двух, трех или четырех
репликационных унипроцессоров, которые исполняют прикладную программу и
поддерживаются механизмом голосования, чтобы отфильтровывать результаты машин.
Правильное функционирование  распределенной системы при наличии поврежденных
компонент требует довольно сложной алгоритмической поддержки.

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

(5)  Упрощение
разработки благодаря специализации. Разработка компьютерной системы может
быть сложной, особенно если требуется значительная функциональность. Разработка
может быть зачастую упрощена разбитием системы на модули, каждый из которых
отвечает за часть функциональности и коммутируется с другими модулями.
         На уровне одной программы модульность достигается определением
абстрактных типов данных и процедур для различных задач. Большая система может
быть определена как набор кооперирующих процессов. В обоих случаях, модули
могут быть исполнены в рамках одного компьютера. Но также возможно иметь
локальную сеть с различными типами компьютеров: один снабжен специальным оборудованием
для вычислений, другой – графическим оборудованием, третий – дисками и т.д.

1.1.2 Компьютерные сети

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

Глобальная сеть обычно соединяет
компьютеры, принадлежащие различным организациям (предприятия, университеты и
т.д.). Физическое расстояние между узлами обычно составляет 10 километров и
более. Каждый узел такой сети – это законченная компьютерная система,
включающая всю периферию и значительное количество прикладного программного
обеспечения. Главная задача глобальной сети – это обмен информацией между
пользователями различными узлов.

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

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

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

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

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

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

Раздел 1.1.3 посвящен краткому
обсуждлению глобальных сетей, локальные сети обсуждаются в разделе 1.1.4.

1.1.3 Глобальные сети

Историческое развитие.
Большая часть первооткрывательской работы в развитии глобальных компьютерных
сетей было проделано в проектах агентства ARPA министерства обороны США. Сеть ARPANET
начала работать в 1969, и соединяла в то время 4 узла. Эта сеть выросла до
нескольких сотен узлов, и другие сети были установлены с использованием
подобной технологии (MILNET, CYRPRESS). ARPANET содержит специальные узлы
(называемые процессорами интерфейса сообщений (IMP)), которые предназначены
только для обработки потока сообщений.

Когда UNIX системы стали широко
использоваться, было признана необходимость информационного обмена между
различными UNIX машинами, для чего была написана программа uucp (Unix-to-Unix
CoPy). С помощью этой программы можно обмениваться файлами по телефонным
каналам и сетям с пользователями UNIX – эта программа дала название
быстрорастущим UUCP сетям. Также другая большая сеть, BITNET, была
разработана в восьмидесятые, так как ARPANET принадлежала министерству обороны
и только несколько организаций могли к ней подключаться.

Сегодня все эти сети соединены
между собой с помощью узлов, которые принадлежат двум сетям (называемые
шлюзами) и позволяющих обмениваться информацией узлам различных сетей. Введение
унифицированного адресного пространства превратило все сети в одну виртуальную
сеть, известную как Internet. Электронный адрес автора ([email protected])
обеспечивает информацию о сети, к которой подключен его департамент.

Алгоритмические проблемы и
проблемы организации. Глобальные сети всегда организованы как сети типа точка-точка.
Это означает, что коммуникация между парой узлов осуществляется при помощи
механизма особенного по отношению к этим двум узлам. Такой механизм может быть
телефонной линией, оптоволокном или спутниковой связью и т.д. Структура
соединений в сетях точка-точка может быть хорошо изображена, если нарисовать
каждый узел как окружность и связи между ними как линии, если линия
коммуникация существует между этими двумя узлами, см. рис. 1.1. Говоря
техническим языком, структура представляется графом, грани которого
представляют собой линии коммуникации в сети. Сводка по терминологии теории
графов приведена в Дополнении Б.

Рис. 1.1 Пример сети
точка-точка

Основное назначение глобальных
сетей – это обмен информацией, например, в форме электронной почты, досок
объявлений, и удаленных файлов. Разработка приемлемой системы коммнуникаций для
этих целей требует решения следующих алгоритмических проблем, некоторые из
которых обсуждаются в Части 1 этой книги.

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

(2)  Выбор путей
коммуникации. (глава 4). В сети точка-точка обычно слишком дорого
обеспечивать связь между каждой парой узлов. Следовательно, некоторые пары
узлов должны положиться на другие узлы для того, чтобы взаимодействовать.
Проблема маршрутизации касается выбора пути (или путей) между узлами, которые
хотят взаимодействовать. Алгоритм, используемый для выбора пути, связан со
схемой, по которой узлы именуются, т.е. форматом адреса, который узел должен
использовать, чтобы послать сообщение другому узлу. Выбор пути в промежуточных
узлах производится с использованием адреса, и выбор может быть сделан эффективно,
если в адресе кодируется в адресах.

(3)  Контроль
перегрузок. Пропускная способность коммутируемой сети может сильно падать,
если много сообщений передается одновременно. Поэтому генерирование сообщений
различными узлами должно управляться и должно зависеть от свободных мощностей сети.
Некоторые методы предотвращения перегрузок обсуждаются в [Tann88, раздел 5.3].

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

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

1.1.4 Локальные сети

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

                                                                                                          Узлы

Система
коммуникаций

 

Рис.
1.2 Сеть с шинной организацией

                                                                                                          Примеры и 
организация. В первой половинек 1970-х локальная сеть Ethernet была
разработана Xerox. В то время как имена глобальных сетей ARPANET, BITNET, и
т.д. происходят от конкретных сетей, имена локальных сетей – это обычно имена
производителей. Есть одна ARPANET, одна BITNET, и одна UUCP сеть, каждая
компания может установить свою собственную Ethernet, Token Ring или SNA сеть.

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

Устройство
Ethernet разрешает передачу только одного сообщения в каждый момент времени;
другие разработки, такие как токен ринг (разработанный в лаборатории Цюрих
IBM), допускает пространственное использование, которое означает, что
несколько сообщений могут передаваться через механизм коммуникации
одновременно. Шинная организация требует немного аппаратуры и поэтому дешевая,
но имеет тот недостаток, что эта организация не очень хорошо масштабируется.
Это означает, что существует очень жесткий потолок числа узлов, которые могут
быть соединены одной шиной. Большие компании со многими компьютерами должны
соединять их несколькими шинами, и использовать мосты для соединения шин
друг с другом, создавая иерархию всей сети организации.

Не все
локальные сети используют шинную организацию. IBM разработала точка-точка
сетевой продукт называемый SNA для того, чтобы позволить покупателям соединять
их разнообразные продукты IBM. Разработка SNA усложнялась требованием ее
совместимости с почти каждым сетевым продуктом, уже предлагаемым IBM.

Алгоритмические
проблемы. Внедрение локальных сетей требует решения некоторых, но не всех,
проблем, рассмотренных в предыдущем подразделе по глобальным сетям. Надежный
обмен данными не такая большая проблема, потому что шины обычно очень надежны и
быстры. Проблема маршрутизации не встает в шинных сетях, потому что каждое
назначение может быть адресовано прямо по сети. В кольцевых сетях все сообщения
обычно посылаются в одном направлении вдоль кольца и удаляются либо получателем,
либо отправителем, что также делает проблему маршрутизации исчерпанной. В шине
нет перегрузки благодаря тому, что каждое сообщение принимается (берется с
шины) немедленно после его отправки, но все равно необходимо ограничивать
нагрузку от сообщений, ожидающих в узлах выхода на шину. Раз сообщения не
сохраняются в промежуточных вершинах, то и не возникает тупика типа
сохрани-и-передай. Нет необходимости в механизмах безопасности помимо той
обычной защиты, предлагаемой операционной системой, если компьютерами владеет одна
компания, которая доверяет своим сотрудникам.

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

(1)  Широковещание
и синхронизация (глава 6). Если информация должна быть доступна всем процессам,
или все процессы должны ждать выполнения некоторого глобального условия,
необходимо иметь схему передачи сообщений, которая каким-либо образом
«дозванивается» до всех процессов.

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

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

(4)  Распределение
ресурсов. Узел может потребовать доступ к некоторым ресурсам, которые доступны,
где-либо в сети, но не знает, где этот ресурс находится. Поддержка таблицы,
которая показывает местоположение каждого ресурса не всегда адекватна, потому
что число потенциальных ресурсов может быть слишком большим для этого, или
ресурсы могут мигрировать от одного узла к другому. В этом  случае, запрашивающий
узел может опрашивать все или некоторые узлы на предмет доступности ресурса,
например, используя широковещательный механизм. Алгоритмы для этой проблемы
могут базироваться на волновых механизмах, описанных в главе 6, см., например
Баратц и другие [BGS87].

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

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

(7)  Распределенная
поддержка файлов. Когда узлы помещают запросы на чтение и запись удаленного
файла, эти запросы, могут обрабатываться в произвольном порядке, и отсюда
должна быть предусмотрена мера для уверенности в том, что каждый узел наблюдает
целостный вид файла или файлов. Обычно это производится временным штампованием
запросов, также как и информации в файлах и упорядочивание входящих запросов по
их временным отметкам; см., например, [LL86].

 

 

 

1.1.5 Многопроцессорные компьютеры

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

Параллельные
компьютеры подразделяются на одно-командные много-поточные по данным (или SIMD)
и много-командные много-поточные по данным (или MIMD) машины.

Рис. 1.3 
Транспьютер и микросхема маршрутизатора

SIMD машины
имеют один интерпретатор инструкций, но команды выполняются большим числом
арифметических блоков. Ясно, что эти блоки имеют недостаток автономности,
которая требуется в нашем определении распределенных систем, и поэтому SIMD
компьютеры не будут рассматриваться в этой книге. MIMD машины состоят из
нескольких независимых процессоров и они классифицируются как распределенные
системы.

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

Очень
популярным процессором для разработки многопроцессорных компьютеров является
транспьютер, разработанный Inmos; см. рис. 1.3. Транспьютер состоит из
центрального процессора (CPU), специального блока с плавающей точкой (FPU),
локальной памяти, и четырех специальных процессоров. Чипы очень хорошо подходят
для построения сетей степени 4 (т.е. каждый узел соединен с четырьмя другими узлами).
Inmos также производит специальные чипы для коммуникации, называемые
маршрутизаторами. Каждый маршрутизатор может одновременно обрабатывать трафик
32 транспьютерных соединений. Каждое входящее сообщение просматривается на
предмет того, по какой связи оно может быть перенаправлено; затем оно
направляется по это связи.

Другой пример
параллельного компьютера это система Connection Machine CM-5, разработанная
Thinking Machines Corporation [LAD92]. Каждый узел машины состоит из быстрого
процессора и обрабатывающих блоков, таким образом, предлагая внутренний
параллелизм в добавление параллелизму, происходящему благодаря наличию
нескольких узлов. Так как каждый узел имеет потенциальную производительность 128
миллионов операций в секунду, и одна машина может содержать 16384 узлов, полная
машина может выполнять свыше 1012 операций в секунду. (Максимальная
машина из 16384 процессоров занимает комнату 900 м2 и скорее всего
очень дорогая.) Узлы СМ-5 соединены тремя точка-точка коммуникационными сетями.
Сеть данных, с топологией толстого дерева, используется для обмена данными по
технологии точка-точка между процессорами. Сеть управления, с технологией
бинарного дерева, осуществляет специальные операции, такие как глобальная
синхронизация и комбинирование ввода. Диагностическая сеть невидима для
программиста и используется для распространения информации о вышедших из строя
компонентах.. Компьютер может быть запрограммирован как в режиме SIMD, так и в
(синхронном) MIMD режиме.

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

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

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

        Inmos
С104 маршрутизаторы используют очень простой алгоритм маршрутизации, называемый
внутренней маршрутизацией, которая обсуждается в подразделе 4.4.2, он не может
быть использован в сетях с произвольной топологией. Это поднимает вопрос могут
ли использоваться решения для проблем, например, предотвращение тупиков, в
комбинации с механизмом маршрутизации (см. проект 5.5).

(2)  Разработка
виртуальной разделяемой памяти. Многие параллельные алгоритмы разработаны
для так называемой модели параллельной памяти с произвольным доступом (PRAM), в
которой каждый процессор имеет доступ к разделяемой памяти. Архитектуры с
памятью, которая разделяется физически, не масштабируются; здесь имеет место
жесткий предел числа процессоров, которые могут быть обслужены одним чипом
памяти.

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

(3)  Балансировка
загрузки. Вычислительная мощь параллельного компьютера эксплуатируется
только, если рабочая нагрузка вычислений распределена равномерно по
процессорам; концентрация  работы на одном узле понижает производительность до
производительности одного узла. Если все шаги вычислений могут быть определены
во время компиляции, то возможно распределить их статически. Более трудный
случай возникает, когда блоки работы создаются динамически во время вычисления;
в этом случае требуются сложные методы. Очереди задач процессоров должны регулярно
сравниваться, после чего задачи должны мигрировать от одной к другой. Для
обзора некоторых методов и алгоритмов для балансировки загрузки см. Гочинский
[Gos91, глава 9] или Харгет и Джонсон [HJ90].

(4)  Робастость
против необнаруживаемых сбоев (часть 3). В репликационной системе должен
быть механизм для преодоления сбоев в одном или нескольких процессорах.
Конечно, компьютерные сети должны также продолжать их функционирование,
несмотря на сбои узла, но обычно предполагается, что такой сбой может быть
обнаружен другими узлами (см., например, алгоритм сетевого обмена в разделе
4.3). Предположения, при которых репликационные системы должны оставаться
правильными, более строгие, т.к. процессор может производить ошибочный ответ, и
то же время кооперироваться с другими при помощи протоколов как правильно
работающий процессор. Должен быть внедрен механизм голосования, чтобы
отфильтровывать результаты процессоров, так, что только правильные ответы
передаются во все время, пока большинство процессоров работает правильно.

1.1.6 Взаимодействующие процессы

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

Классический
пример для иллюстрации этого упрощения это преобразование записей Конвея. Проблема
состоит в том, чтобы читать 80 символьные записи и записывать ту же информацию
в 125 символьные записи. После каждой входной записи должен вставляться
дополнительный пробел, и каждая пара звездочек («**») должна заменяться на восклицательный
знак («!»). Каждая выходная запись должна завершаться символов конца записи
(EOR). Преобразование может быть проведено одной программой, но написание этой
программы очень сложно. Все функции, т.е. замена «**» на «!», вставка пробелов,
и вставка символов EOR, должны осуществляться за один цикл.

Программу лучше
структурировать как два взаимодействующих процесса. Первый процесс, скажем р1,
читает входные карты и конвертирует входной поток в поток печатных символов, не
разбивая на записи. Второй процесс, скажем р2, получает поток символов и
вставляет EOR после 125 символов. Структура программы как набор двух процессов
обычно предполагается для операционных систем, телефонных переключающих
центров, и, как мы увидим в подразделе 1.2.1, для коммуникационных программ в
компьютерных сетях.

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

Процессы,
которые выполняются на одном компьютере, имеют доступ к одной физической
памяти, отсюда – естественно использование этой памяти для коммуникации. Один
процесс пишет в определенное место памяти, и другой процесс читает из этого
места. Эта модель конкурирующих процессов была использована Дейкстрой [Dij68] и
Овицким и Грайсом [OG76]. Проблемы, которые рассматривались в этом контексте,
включают следующие.

(1)  Атомичность
операций с памятью. Часто предполагается, что чтение и запись одного слова
памяти атомичны, т.е. чтение и запись выполняемые процессом завершается перед
тем как другая операция чтения или записи начнется. Если структуры большие,
больше чем одно слово обновляется, операции должны быть аккуратно синхронизированы,
чтобы избежать чтения частично обновленной структуры. Это может быть
осуществлено, например, применением взаимного исключения [Dij68] в структуре:
пока один процесс имеет доступ к структуре, ни один другой процесс не может
начать чтение или запись. Применение взаимного исключения с использованием
разделяемых переменных усложнено из-за возможности нескольких процессов искать
поле в этой структуре  в это же время.

Условия ожидания, налагаемые доступом со взаимным исключением  к
разделяемым данным, могут понизить производительность процессов, например, если
«быстрый» процесс должен ждать данные, в настоящее время используемые
«медленным» процессом. В недавние годы внимание концентрировалось на применении
разделяемых переменных, которые являются wait-free, что значит, что процесс
может читать или писать данные без ожидания любых других процессов. Чтение и
запись могут перекрываться, но только при тщательной проработке алгоритмов
чтения и записи, которые должны обеспечить атомичность. Для обзора алгоритмов
для wait-free атомичных разделяемых переменных см. Киросис и Кранакис [KK89].

(2)  Проблема
производитель-потребитель. Два процесса, один из которых пишет в
разделяемый буфер и другой и которых читает из буфера, должны быть
скоординированы, чтобы предупредить первый процесс от записи, когда буфер полон
и второй процесс от чтения, когда буфер пуст. Проблема
производитель-потребитель возникает, когда решение проблемы преобразования
Конвея выработано; р1 производит промежуточный поток
символов, и р2 потребляет его.

(3)  Сборка
мусора. Приложение, которое запрограммировано с использованием динамических
структур данных может производить недоступные ячейки памяти, называемые мусором.
Формально, приложение должно бы прерваться, когда у системы памяти кончается
свободное место, для того чтобы позволить специальной программе, называемой сборщиком
мусора, идентифицировать и вернуть недоступную память. Дейкстра и другие
[DLM78] предложили сборщик мусора на-лету, который может работать как отдельный
процесс, параллельно с приложением.

Требуется сложное взаимодействие между приложением и сборщиком, т.к.
приложение может модифицировать структуры указателей в памяти, в то время как
сборщик решает какие ячейки являются недоступными. Алгоритм должен быть
тщательно проанализирован, чтобы показать, что модификации не обусловят
ошибочный возврат доступным ячеек. Алгоритм для сбора мусора на-лету с
упрощенным доказательством правильности был предложен Бен-Ари [BA84].

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

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

Семафоры – подходящее средство для применения взаимного исключения над
разделяемой структурой данных: семафор инициализируется в 1, и доступ к
структуре предваряется операцией Р и завершается операцией V. Семафоры
накладывают большую ответственность на каждый процесс за правильное
использование; целостность разделяемых данных нарушается, если процесс
манипулирует данными неправильно или не выполняет требуемых Р и V  операций.

(2)                 
Мониторы. Монитор [Hoa74] состоит  из структуры данных и набора
процедур, которые могут выполняться над этими данными, с помощью их вызова
процессами способом, использующим взаимное исключение. Т.к. к данным доступ
осуществляется полностью через процедуры, объявленные в мониторе, гарантируется
правильное использование данных, если монитор объявлен корректно. Монитор, таким
образом, предотвращает не позволенный доступ к данным и синхронизирует доступ
различных процессов.

(3)                 
Каналы. Канал [Bou83] это механизм, который передает поток данных
от одного процесса к другому и синхронизирует два коммутирующих процесса; это
заранее запрограммированное решение проблемы производитель-потребитель.

Канал это основной механизм коммуникаций в операционной системе UNIX.
Если программа р1 выполняет процесс р1
преобразования Конвея и р2 выполняет р2 ,
команда UNIX р1 | р2 вызывает две программы
и соединяет их каналом. Вывод р1 буферизируется и становится
вводом р2 ; р1 подвешивается, когда буфер
полон, и р2 подвешивается, когда буфер пуст.

(4)                 
Передача сообщений. Некоторые языки программирования, такие как
OCCAM и ADA, обеспечивают передачу сообщений, как механизм для межпроцессовой
коммуникации. Проблемы синхронизации относительно легко решаются с
использованием передачи сообщений; т.к. сообщение не может быть получено до его
передачи, возникает  временное отношение между событиями благодаря обмену сообщениями.

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

Рис 1.4 Слоеная сетевая
архитектура

1.2 Архитектура и
Языки

 

Программное обеспечение для
выполнения компьютерных сетей связей очень усложнено. В этом разделе объяснено,
как это программное обеспечение обычно структурируется в ациклически зависимых
модулях названных уровнями (Подраздел 1.2.1). Мы обсуждаем два стандарта с 
сетевой архитектурой, а именно, модель МЕЖДУНАРОДНОЙ ОРГАНИЗАЦИИ ПО
СТАНДАРТИЗАЦИИ Соединения Открытых систем, стандарт для глобальных сетей, и
дополнительного стандарта IEEE для локальных сетей (Подразделы, 1.2.2 и 1.2.3).
Также языки, используемые для программирования распределили системы,  кратко обсуждены
(Подраздел 1.2.4).

1.2.1 Архитектура

Сложность задач, выполняемых подсистемой связи
распределенной системы требует, чтобы эта подсистема была разработана высоко
структурированным способом. К этому моменту, сети всегда организовываются как
совокупность модулей, каждое выполнение очень специфическая функция и основывающаяся
на услугах, предлагаемых другими модулями. В сетевых организациях имеется
всегда строгая иерархия между этими модулями, потому что каждый модуль
исключительно использует услуги, предлагаемые предыдущим модулем. Модули
названы уровнями или уровнями в контексте сетевой реализации; см. 1.4 Рисунок.
Каждый уровень осуществляет часть функциональных возможностей, требуемых для
реализации сети и полагается на уровень только ниже этого. Услуги, предлагаемые
i уровнем  i + 1 уровню  точно описаны в интерфейсе i уровня и i + 1 уровня 
(кратко, i / (i + 1) интерфейс). При проектировании сети, в первую очередь,
нужно определить число уровней и интерфейсов между последующими уровнями.

Функциональные возможности каждого уровня должны
быть выполнены распределенным алгоритмом, таким, что алгоритм для i уровня
решает "проблему", определенную i / (i + 1) интерфейсом, согласно
"предположениям", определенным в (i — l) /i интерфейсе. Например, (i
— 1) /i интерфейс может определять, что сообщения транспортируются из узла p к
узлу q, но некоторые сообщения могут быть потеряны, в то время как i / (i + 1)
интерфейс определяет, что сообщения передаются от p до q надежно.
Алгоритмическая проблема для i уровня затем – выполнить надежное прохождение
сообщения, используя ненадежное прохождение сообщения, что обычно делается с
использованием подтверждения и перепередачи потерянных сообщений (см.
Подраздел, 1.3.1 и Главу 3). Решение этой проблемы определяет тип сообщений,
обменянных процессами i уровня и значение этих сообщений, т.е., как процессы
должны реагировать на эти сообщения. Правила и соглашения, используемые в
"сеансе связи" между процессами i уровня упоминаются как layer-i
протокол. Самый низкий уровень иерархии (уровень 0 на Рисунке 1.4) – всегда
аппаратный уровень. Интерфейс 0/1 описывает процедуры,  которыми уровень i может передать необработанную информацию через соединяющие провода, и
описание уровня непосредственно определяет то, какие типы провода используются,
сколько вольт представляют единицу или ноль, и т.д. Важное наблюдение – то, что
изменение в реализации уровня 0 (замена проводов другими проводами или
спутниковыми подключениями) не требует, чтобы  интерфейс 0/1 был изменен. Те же
самые условия в более высоких уровнях: интерфейсы уровня служат экраном от
реализация уровня для других уровней, и реализация может быть изменена без
того, чтобы воздействовать на другие уровни. Под сетевой архитектурой мы
понимаем совокупность уровней и сопровождающих описаний всех интерфейсов и
протоколов. Поскольку сеть может содержать узлы, произведенные различными изготовителями,
программируемые  программным обеспечением, написанным различными компаниями,
важно, чтобы изделия различных компаний являлись совместимыми. Важность совместимости
была признана во всем мире и следовательно стандартные сетевые архитектуры были
разработаны. В следующем подразделе два стандарта обсуждаются, что получило
"официальное" статус, потому что они приняты влиятельными организациями
(МЕЖДУНАРОДНАЯ ОРГАНИЗАЦИЯ ПО СТАНДАРТИЗАЦИИ, и Институт Электрических и Электронных
Инженеров, IEEE). Протокол управления передачей / internet протокол (TCP/IP) –
совокупность протоколов, используемых в Internet. TCP/IP – не официальный
стандарт, но используется настолько широко, что стал фактическим стандартом.
Семейство протоколов TCP/IP (см. Davidson [Dav88] для введения) структурирован
согласно уровням OSI модели, обсужденной в следующем подразделе, но протоколы
могут использоваться в глобальных сетях также как в локальных сетях.

Более высокие уровни содержат протоколы для
электронной почты (простой протокол передачи почты –  SMTP), передача файлов
(протокол передачи файлов, FTP), и двунаправленная связь для удаленного входа в
систему (Telnet).

1.2.2 Ссылочная
Модель  OSI

МЕЖДУНАРОДНАЯ ОРГАНИЗАЦИЯ ПО СТАНДАРТИЗАЦИИ
установила стандарт для компьютерных изделий(программ) для работы с сетями типа
тех, которые используются (главным образом) в глобальных сетях. Их стандарт для
сетевой архитектуры назван Соединением открытых систем (OSI) ссылочной моделью,
и будет описан кратко в этом подразделе. Потому что стандарт не полностью
соответствующий для использования в локальных сетях, дополнительные стандарты
IEEE для локальных сетей обсуждены в следующем подразделе. Модель ссылки OSI
состоит из семи уровней, а именно физического, связи данных, сети, транспорта,
сеанса, представления, и уровней прикладной программы. Ссылочная модель
определяет интерфейсы между уровнями и обеспечивает, для каждого уровня, один
или большее количество стандартных протоколов (распределенные алгоритмы, чтобы
выполнить уровень).

Физический (1) уровень. Цель физического уровня состоит в том, чтобы
передать последовательности битов по каналу связи. Поскольку имя уровня
предполагает, что эта цель достигнута посредством физического подключения между
двумя узлами, типа телефонной линии, волоконно-оптического подключения, или
спутникового подключения. Проект уровня непосредственно – вполне вопрос для
инженеров – электриков, в то время как интерфейс 1/2 определяет процедуры, 
которыми следующий уровень вызывает услуги физического уровня. Обслуживание
физического уровня не надежно; поток битов может быть попорчен в течение передачи.

Канальный уровень  (2). Цель канального уровня состоит в том, чтобы
маскировать ненадежность физического уровня, то есть обеспечивать надежную
связь с более высокими уровнями. Уровень связи данных только осуществляет
надежное подключение между узлами, которые непосредственно связаны физической
связью, потому что он сформирован непосредственно над физическим уровнем.
(Связь между несмежными узлами выполнена в сетевом уровне.) Чтобы достигнуть
цели, уровень делит поток битов на части фиксированной длины, названные кадрами.
Приемник кадра может проверять(отмечать), был ли кадр получен правильно, 
проверяя контрольную сумму, которая является некоторой избыточной информацией,
добавленной к каждому кадру. Имеется обратная связь от приемника до
отправителя, чтобы сообщить отправителю относительно правильно или неправильно
полученного кадра; эта обратная связь происходит посредством сообщений
подтверждения.

Отправитель пошлет кадр снова, если оказалось,
что он получен неправильно или полностью потерян. Общие принципы, объясненные в
предыдущем параграфе могут быть усовершенствованы к ряду различных протоколов
связи данных. Например, сообщение подтверждения может быть послано для кадров,
которые получены (положительные подтверждения) или для кадров, которые
отсутствуют из совокупности полученных кадров (отрицательные подтверждения).
Окончательная ответственность за правильную передачу всех кадров может быть на
отправителе или стороне приемника. Подтверждения могут быть посланы для
одиночных кадров или блоков кадров, кадры могут иметь числа последовательности
или не иметь, и т.д.

Сетевой уровень (3). Цель сетевого уровня состоит в том, чтобы обеспечить
средства связи между всеми парами узлов, не только связанных физическим
каналом. Этот уровень должен выбрать маршруты через сеть, используемую для
связи между не-смежными узлами и должен управлять загрузкой движения в каждом
узле и канале. Выбор маршрутов обычно основан на информации относительно
сетевой топологии, содержащейся в маршрутизации таблиц, сохраненных в каждом
узле. Сетевой уровень содержит алгоритмы, чтобы модифицировать таблицы
маршрутизации, если топология сети изменилась (вследствие сбоя канала или
восстановления). Такой сбой или восстановление обнаруживается канальным уровнем
связи. Хотя канальный уровень обеспечивает надежное обслуживание у сетевого
уровня, обслуживание, предлагаемое сетевым уровнем не надежно. Сообщения
(названные пакетами в этом уровне) посланные от одного узла до другого могут
следовать различными путями, вызывая опасность, что одно сообщение настигнет
другое. Вследствие  сбоев узла сообщения могут быть потеряны (узел может
накрыться во время хранения cообщения), и вследствие лишних сообщений
перепередач могут даже быть дублированы. Уровень может гарантировать
ограниченному пакету срок службы; то есть, существует константа c такая, что
каждый пакет или передается в узел адресата в течение с секунд, или теряется.

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

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

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

Уровень представления (6). Цель уровня представления состоит в том, чтобы
выполнить преобразование данных, где представление информации в одном узле
отличается от представления в другом узле или не подходящее для передачи. Ниже
этого уровня (то есть, при интерфейсе 5/6) данные находятся в передавабельной и
стандартизированной форме, в то время как выше этого уровня (то есть, при
интерфейсе 6/7) данные находятся в пользовательско – или компьютерно –
специфической форме. Уровень выполняет сжатие данных и декомпрессию, чтобы
уменьшить количество данных, переданных через более низкие уровни. Уровень
выполняет шифрование данных и расшифровку, чтобы гарантировать
конфиденциальность и целостность в присутствии злонамеренных сторон, которые
стремятся получать или разрушать переданные данные.

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

1.2.3 OSI Модель в 
локальных сетях: IEEE Стандарты

На  проект ссылочной модели OSI влияют в большой
степени архитектуры существующих глобальных сетей. Технология, используемая в
локальных сетях налагает различные программные требования, и из-за этих
требований некоторые из уровней могут почти совсем отсутствовать в локальных
сетях. Если сетевая организация полагается на общую шину, общедоступную всеми
узлам (см. Подраздел 1.1.4), то сетевой уровень почти пуст, потому что каждая
пара узлов связана непосредственно через шину. Проект транспортного уровня
очень упрощен ограниченным количеством недетерминизма представленного шиной, по
сравнению с промежуточной двухточечной сетью. Напротив, канальный уровень
усложнен фактом, что к  той же самой физической среде обращается потенциально
большое количество узлов. В ответе на эти проблемы IEEE одобрил дополнительные
стандарты, покрывая только более низкие уровни OSI иерархии, для использования
в локальных сетях (или, если быть более точным, во всех сетях, которые являются
структурированными шиной скорее, чем двухточечными соединениями). Потому что
никакой одиночный стандарт не мог бы быть достаточно общий, чтобы охватить все
сети уже широко использующиеся, IEEE одобрил три различных, несовместимых
стандарта, а именно МНОЖЕСТВЕННЫЙ ДОСТУП С ОПРОСОМ НЕСУЩЕЙ И РАЗРЕШЕНИЕМ
КОНФЛИКТОВ, маркерную шину , и эстафетное кольцо. Канальный уровень заменен
двумя подуровнями, а именно управление доступом к среде и подуровни управления
логическим соединением.

Физический (1) уровень. Цель физического уровня в стандартах IEEE подобна
таковому первоначального стандарта МЕЖДУНАРОДНОЙ ОРГАНИЗАЦИИ ПО СТАНДАРТИЗАЦИИ,
а именно передавать последовательности битов. Фактические стандартные описания
(тип монтажа и т.д.), однако, радикально различны, вследствие того, что вся связь
происходит через общедоступную среду, а не через двухточечные подключения.

Medium-access-control подуровень (2a). Цель этого подуровня состоит в том, чтобы
решить конфликты, которые возникают между узлами, которые хотят использовать
общедоступную среду связи. Статичный подход раз и навсегда планировал бы
интервалы времени, в течение которых каждому узлу позволяют использовать среду.
Этот метод теряет много пропускной способности, однако, если только несколько
узлов имеют данные, чтобы передавать, и все другие узлы тихи, среда остается в
простое в течение времен, планируемых для тихих узлов. В шинах маркера и
эстафетных кольцах доступ к среде находится по карусельному принципу: узлы
циркулируют привилегию, названную маркером, среди них, и узлу, задерживающему
этот маркер, позволяют использовать среду. Если узел, задерживающий маркер, не
имеет никаких данных, чтобы передать, он передает маркер к следующему узлу. В
эстафетном кольце циклический порядок, в котором узлы получают их право хода, 
определен физической топологией подключения (который,  действительно, кольцо),
в то время как в шине маркера,  циклический порядок определен динамически
основываясь на порядке адресов узлов. В стандарте МНОЖЕСТВЕННОГО ДОСТУПА С
ОПРОСОМ НЕСУЩЕЙ И РАЗРЕШЕНИЕМ КОНФЛИКТОВ узлы наблюдают, когда среда неактивна,
и если так, то им позволяют послать. Если два или больше узла запускают посылку
(приблизительно) одновременно, имеется проверка на пересечение, которое обнаруживается,
что заставляет каждый узел прерывать передачу и пытаться снова в более позднее
время.

Logical-link-control подуровень (2b). Цель этого уровня сравнима с целью канального
уровня в OSI модели, а именно: управлять обменом данными между узлами. Уровень
обеспечивает управление ошибками и управление потоком данных, используя методы,
подобные тем использованных в OSI протоколах, а именно числа последовательности
и подтверждения. Видящийся с точки зрения более высоких уровней,
logical-link-control подуровень появляется подобно сетевому уровню OSI модели.
Действительно, связь между любой парой узлов происходит без того, чтобы
использовать промежуточные узлы, и может быть обработана непосредственно
logical-link-control подуровнем. Отдельный сетевой уровень не следовало бы
выполнять в локальных сетях; вместо этого, транспортный уровень сформирован
непосредственно на верхней части logical-link-control подуровня.

1.2.4 Поддержка Языка

 

Реализация одного из программных уровней сети
связей или распределенной прикладной программы требует, чтобы распределенный
алгоритм, используемый в том уровне или прикладной программе был кодирован на
языке программирования. На  фактическое кодирование конечно высоко влияет язык
и особенно примитивы, которые он предлагает. Так как в этой книге мы концентрируемся
на алгоритмах и не на их кодировании как программа, наша базисная модель
процессов основана на состояниях процесса и переходах состояния (см. Подраздел
2.1.2), а не на выполнении команд, принимаемых из предписанного набора.
Конечно, неизбежно, чтобы там, где мы представили алгоритмы, требовалась
некоторая формальная запись; запись программирования, используемая в этой книге
обеспечена в Приложении A. В этом подразделе мы описываем некоторые из
конструкций, которые можно наблюдать в фактических языках программирования,
разработанных для распределенных систем. Мы ограничиваемся здесь кратким
описанием этих конструкций; Для большего количества деталей и примеров
фактических языков, которые используют различные конструкции, см., например,
Bal [Bal90]. Язык для программирования распределенных прикладных программ,
должен обеспечить средства, чтобы выразить параллелизм, обрабатывать
взаимодействие, и недетерминизм. Параллелизм, конечно, требуется для
программирования различных узлов системы таким способом, которым узлы выполнят
их часть программы одновременно. Связь между узлами должна также быть
поддержана в соответствии с языком программирования. Недетерминизм необходим,
потому что узел должен иногда быть способен получить сообщение от различных
узлов, или быть способным либо посылать, либо получать сообщение.

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

Связь. Связь между процессами свойственна распределенным системам: если
процессы не связываются, каждый процесс функционирует в изоляции от других
процессов и должен изучаться в изоляции, a не как часть распределенной системы.
Когда процессы сотрудничают в вычислении, связь необходима, если один процесс
нуждается в промежуточном результате, произведенном другим процессом. Также,
синхронизация необходима, потому что вышеупомянутый процесс должен быть
приостановлен, пока результат не доступен. Прохождение cообщения затрагивает, и
связь и синхронизацию; общедоступная память затрагивает только связь:
дополнительная осторожность должна быть предусмотрена для синхронизации процессов,
которые сообщаются c использованием общедоступной памяти. В языках, которые
обеспечивают передачу сообщения, доступны операции "посылать" и
"получать". Связь происходит выполнением посылающейся операции в
одном процессе (следовательно названным процессом отправителя) и получающейся
операцией в другом процессе (процесс приемника). Параметры посылающей операции
– адрес приемника и дополнительные данные, формирующие содержание сообщения.
Эти дополнительные данные становятся доступными приемнику, когда получающая
инструкция выполнена, то есть, таким образом осуществляет связь. Получающая
операция может быть завершена только после того, как посылающая операция была выполнена,
что и осуществляет синхронизацию. В некоторых языках получающая операция не
доступна явно; вместо этого, процедура или операция активизируется неявно,
когда сообщение получено. Язык может обеспечивать синхронное прохождение
сообщения, когда посылающая операция завершена только после выполнения
получающей операции.

Другими словами, отправитель блокирован, пока
сообщение не было получено, и имеет место двухсторонняя синхронизация между
результатами приемника и отправителем. Сообщения могут быть посланы
двухточечно, то есть, от одного отправителя на один приемник, или
широковещательно, когда то же самое сообщение получено всеми приемниками.
Термин мультиприведение также используется, чтобы обратиться к сообщениям,
которые посланы совокупности (не обязательно всех) процессов. Несколько более
структурированный примитив связи –  удаленный вызов процедуры (RPC). Чтобы
связываться с процессом b, процедура a обращается к процедуре, представленной в
процессе b,  посылая параметры процедуры в сообщении; а приостанавливается,
пока результат процедуры не будет возвращен в другом сообщении. Вариант для прохождения
сообщения – использование общедоступной памяти для связи; один процесс пишет
значение переменной, и другой процесс читает значение. Синхронизация между
процессами тяжелее, чтобы ее достигнуть, потому что чтение переменной может
быть использовано прежде, чем переменная была записана. При использовании
примитивов синхронизации типа семафоров [Dij68] или мониторов [Hoa78], возможно
выполнить передачу сообщения, в среде общедоступных  переменных. И наоборот,
также возможно выполнить (виртуальную) общедоступную память в передающей
сообщения среде, но это очень неэффективно.

Недетерменизм. В многих точках в выполнении процесс может быть способен продолжиться
различными способами. Получающая операция часто недетерминирована, потому что
это позволяет получение сообщений от различных отправителей. Дополнительные
способы выражать недетерменизм основаны на охраняемых командах. Охраняемая команда
в наиболее общей форме – список инструкций, каждый предшествованный булевым
выражением (его защитником). Процесс может продолжать выполнение с любой из
инструкций, для которых соответствующая защита оценивается истиной. Защита
может содержать получающую операцию, когда она оценивается истиной, если
имеется сообщение, доступное, чтобы быть полученным.

1.3 Распределенные
Алгоритмы

 

Предыдущие разделы дали причины для использования
распределенных компьютерных систем и объяснили характер этих систем; потребность
программировать эти системы возникает как следствие. Программирование распределенных
систем должно быть основано на использовании правильных, гибких, и эффективных
алгоритмов. В этом разделе обсуждается, что разработка распределенных
алгоритмов – ремесло, совершенно различное по характеру от ремесла,
используемого в разработке централизованных алгоритмов. Распределенные и
централизованные системы отличаются по ряду существенных отношений, обрабатываемых
в Подразделе 1.3.1 и иллюстрируемых в 1.3.2 Подразделе. Распределенное
исследование алгоритмов следовательно развилось как независимое поле научного
исследования; см. 1.3.3 Подраздел. Эта книга предназначена, чтобы представить
читателю это поле исследования. Цели книги и выбора результатов, включенных в
книгу установлены в  Подразделе 1.3.4.

1.3.1 Распределенный
против Централизованных Алгоритмов

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

(1) Недостаток знания  глобального состояния.
В централизованных решениях управление алгоритмом может быть сделано основанным
на наблюдениях состояния системы. Даже при том, что к  всему состоянию обычно
нельзя обращаться в одиночной машинной операции, программа может осматривать
переменные один за другим, и принимать решение, в конце концов релевантная
информация будет расценена. Никакие данные не изменяются между проверкой и
решением, и это гарантирует целостность решения. Узлы в распределенной системе
имеют доступ только к их собственному состоянию и не к глобальному состоянию
всей системы. Следовательно, не возможно делать решение управления основанным
на глобальном состоянии. Это имеет место тот факт, что узел может получать
информацию относительно состояния других узлов и базировать решения управления
на этой информации. В отличие от централизованных систем, факт, что полученная
информация является старой, может стать причиной получения недопустимой
информации, потому что состояние другого узла, возможно, изменилось между посылкой
информации состояния и решения, основанного на этом. Состояние подсистемы связи
(то есть, какие сообщения находятся в транзите в  некоторый момент) никогда
непосредственно не наблюдается узлами. Эта информация может только быть
выведена косвенно,  сравнивая информацию относительно сообщений, посланных и
полученных узлами. Недостаток глобального кадра времени. События,
составляющие выполнение централизованного алгоритма полностью упорядочиваются
естественным способом их временным появлением;  для каждой пары событий, каждое
происходит ранее или позже чем другое. Временное отношение, вызванное на
событиях, составляющих выполнение распределенного алгоритма – не общее
количество; Для некоторых пар событий может иметься причина для решения, что
каждое происходит перед другим, но для других пар имеет место, что ни одно из
событий не происходит перед другим [Lam78]. Взаимное исключение может быть
достигнуто в централизованной системе требующих его, если доступ процесса p к
ресурсу начинается позже чем доступ процесса q, то доступ процесса p начался
после того, как доступ процесса q закончился. Действительно, все такие события
(старт и окончание доступа процессов p и q) полностью упорядочиваются отношением
временного предшествования; в распределенной системе они – не упорядочиваются,
и та же самая стратегия не достаточна. Процессы p и q могут начать обращаться к
ресурсу, в то время как начало одного не предшествует началу другой.

(3) Недетерменизм. Централизованная
программа может описывать вычисления, поскольку они разворачиваются из
некоторого ввода недвусмысленно; имея данную программу и ввод, только одиночное
вычисление возможно. Напротив, выполнение распределенной системы обычно не
-детерминировано, из-за возможных различий в быстродействии выполнения компонентов
системы.

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

 Комбинация недостатка знания относительно
глобального состояния, недостаток глобального кадра времени, и недетерменизм
делает проект распределенных алгоритмов запутанным ремеслом, потому что три
аспекта вмешиваются несколькими способами. Понятия времени и состояния очень
связаны; в централизованных системах понятие времени может быть определено, 
рассматривая последовательность состояний, принятых системой в течение
выполнения. Даже при том, что в распределенной системе глобальное состояние
может быть определено, и выполнение может рассматриваться как
последовательность глобальных состояний (Определение 2.2), это представление
имеет ограниченное использование, так как выполнение может также быть описано
другими последовательностями глобальных состояний (Теорема 2.21). Те
альтернативные последовательности обычно состоят из различных глобальных
состояний; это придает утверждению "система, принимала это или то
состояние в течение выполнения " очень сомнительное значение. Недостаток
знания относительно глобального состояния мог бы компенсироваться, если было возможно
предсказать это глобальное состояние из алгоритма, который выполняется. К
сожалению, это не возможно из-за свойственного недетерменизма в выполнении
распределенных систем.

Рис. 1.5 Упрощенная сетевая архитектура

1.3.2 Пример: Связь с 
одиночным сообщением

Мы проиллюстрируем трудности, налагаемые
недостатком знания относительно глобального состояния и недостатка глобального
кадра, с помощью примера, обсужденного Beisnes [Bel76l, а именно надежный обмен
информацией через ненадежную среду. Рассмотрим два процесса a и b, связанных
сетью передачи данных, которая передает сообщения от одного процесса до
другого. Сообщение может быть получено в произвольно длительное время после
того, как оно послано, оно может также быть потеряно в целом в сети. Надежность
связи увеличивается при использовании сетевых процедур управления (NCPs), через
который a и b обращаются к сети. Процесс a инициализирует связь,  передавая
информационный модуль m к NCP A. Взаимодействие между NCPs (через
сеть передачи данных, DN) должно гарантировать, что информация m
передана в процесс b (NCP B), после которого a уведомляется относительно
доставки (через NCP A). Структура связи изображена в Рисунке 1.5. Даже если
только одиночный информационный модуль должен транспортироваться от a до b,
ненадежность сети вынуждает NCP A и NCP B вовлекаться в сеанс связи, состоящий
из нескольких сообщений. Они поддерживают информацию состояния относительно
этого сеанса связи, но потому что число возможных партнеров сеанса связи для
каждого процесса большое, то требуется, чтобы информация состояния была
отброшена после того, как обмен сообщениями завершен. Инициализация информации
состояния называется открытие, и ее отбрасывание называется закрытием
сеанса связи. Заметьте, что после закрытия сеанса связи, NGP находится в точно
том же самом состоянии как и перед открытием его; это называется закрытым
состоянием. Информационный модуль m.,  говорят, потерян, если a
получил уведомление от b, но модуль фактически не был никогда передан к b.
Модуль m,  говорят, дублирован если он был передан дважды.
Надежные механизмы связи предотвращают и потери и дублирования. Принимается,
что NCPs могут терпеть неудачу, после которой они перезапускаются в закрытом
состоянии (действительно теряя всю информацию относительно открытого в настоящее
время сеанса связи).

Никакая надежная связь не достижима. Как первое наблюдение, может быть показано, что
независимо от того, как запутанно NCPs разработаны, не возможно достигнуть
полностью надежной связи. Это наблюдение может быть сделано независимо от
проекта сети передачи данных или NCPs и только полагается на предположение, что
NCP может терять информацию относительно активного сеанса связи. Чтобы видеть
это, предположим, что после того, как инициализация связи a, NCP и NCP В
запускает разговор(сеанс связи), в течение которого NCP В доставляет м. b после
получения сообщения М. из NCP A. Рассмотрите случай где NCP В сбоями и
перезапущен в закрытом состоянии после того, как NCP послал сообщение, м. В
этой ситуации, ни NCP ни NCP В не может сообщать, был ли м. уже поставлен,
когда NCP В потерпел крах; NCP,  потому что это не может наблюдать события в
NCP В (недостаток знания относительно глобального состояния) и NCP В, потому
что это потерпело крах и было перезапущено в закрытом состоянии. Независимо от
того, как NCPs продолжают их разговор(сеанс связи), ошибку можно представлять.
Если NCP посылает сообщение NCP В, снова и NCP В доставляет сообщение, дублирование
может возникать. Если сообщение к дано без поставки, потеря может возникать. Мы
теперь оценим несколько возможных проектов NCPs относительно возможности потери
или дублирования сообщений. Мы пробуем разрабатывать протоколы таким способом,
которым потерь избегают в любом случае.

Cеанс связи с одним сообщением. В самом простом возможном проекте, NCP А посылает
данные, неизменные через сеть, сообщает об этом a, и закрывается, в одиночном
действии после инициализации. NCP В всегда доставляет сообщение, которое
он получает, к b и закрывается после каждой доставки. Этот протокол
представляет потерю всякий раз, когда сеть отказывается доставлять сообщение,
но не имеется никакой возможности введения дублирований.

Cеанс связи с двумя сообщениями. Ограниченная защита против потери сообщений
предлагается добавлением подтверждений к протоколу. В нормальном сеансе связи,
NCP А посылает сообщение данных (данные, m) и ждет получения
сообщения подтверждения (ack) из NCP B. Когда это сообщение получено,
NCP А закрывает сеанс связи. NCP B, после получения сообщения (данные,
m), доставляет m к b, отвечает  сообщением (ack), и закрывается. Подводя
итоги, можно сказать, что свободный от ошибок сеанс связи состоит из трех
событий.

1. NCP А send (данные, m)

2. NCP B receive (данные, m), 
deliver m., send (ack), close

3. NCP А receive (ack), notify,
close.

 Возможность потери сообщения данных вынуждает
NCP А посылать (данные, m) снова, если подтверждение не получено
после некоторого времени. (Из-за недостатка знания относительно глобального
состояния, NCP А не может наблюдать, были ли (данные, m)
потеряны, (ack) был потерян, или NCP B потерпел крах между
получением (данные, m) и посылкой (ack).) К этому моменту, NCP A
ждет получения подтверждения в течение ограниченного количества времени, и
если никакое такое сообщение не получено, таймер переполняется и происходит
таймаут. Может быть легко замечено, что эта опция перепередачи представляет
возможность дубликата, а именно, если не первоначальное сообщение данных, а
подтверждение было потеряно, как в следующем сценарии:

1. NCP A           send ( data, m)

2. NCP B           receive (data,
m), deliver m, send (ack), close

3. DN                 ( ack ) is lost

4. NCP A           timeout, send (
data, m)

5. NCP B           receive (data, m),
deliver m, send (ack), close

6. NCP A           receive (ack), notify,
close

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

1. NCP A           send ( данные,
m1 )

2. NCP B           receive (данные,
m1), deliver m1, send (ack), close

3. NCP A           timeout, send (
данные, m1 )

4. NCP B           receive (данные,
m1), deliver m1, send (ack), close

5. NCP A           receive (ack),
notify, close

6. NCP A           send ( данные,
m2)

7. DN                 ( данные, m2 )
is lost

8. NCP A           receive (ack)
(step 2), notify, close

Сообщение m1 дублировано как в предыдущем
сценарии, но первое подтверждение было доставлено медленно, а не потеряно,
вызывая потерю более позднего информационного модуля. Медленная доставка не
обнаружена из-за недостатка глобального времени. Проблема надежной связи между
процессами может быть решена более легко, если принято слабое понятие
глобального времени, а именно, существует верхняя граница T  задержки передачи
любого сообщения, посланного через сеть. Это называется глобальным предположением
синхронизации, потому что это порождает временное отношение между событиями в
различных узлах (а именно, посылка NCP А и получение NCP B). Получение
сообщений от более ранних сеансов связи может быть предотвращено в этом
протоколе закрытием сеанса связи в NCP А только через 2T после посылки
последнего сообщения.

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

1. NCP A           send (data, m)

2. NCP B           receive (data,
m), deliver m, send (ack)

3. NCP A           receive (ack),
notify, send (close), close

4. NCP B           receive (close),
close

Потеря  сообщения (данные, m)  вызывает
таймаут в NCP A, когда NCP A повторно  передает сообщение. Потеря
сообщения (ack)  также вызывает перепередачу (данные, m), но это
не ведет к дублированию, потому что NCP В имеет открытый сеанс связи и
распознает сообщение, которое он уже получил.

К сожалению, протокол может все еще терять и
дублировать информацию. Потому что NCP В должен быть способен закрыться даже,
когда сообщение (close) потеряно, NCP В должен повторно передать (ack)
сообщение, если он не получает никакого сообщения (close). NCP A
отвечает, говоря, что он не имеет никакого сеанса связи ( сообщение (nocon)),
после которого NCP В закрывается. Перепередача (ack) может прибывать,
однако, в следующем сеансе связи NCP A  и интерпретироваться как
подтверждение в том сеансе связи, вызывая тот факт, что следующий
информационный модуль будет потерян, как в следующем сценарии.

1. NCP A           send ( data, m1
)

2. NCP B           receive (data,
m1), deliver m1, send (ack)

3. NCP A           receive (ack),
notify, send (close), close

4. DN                 ( close ) is lost

5. NCP A           send ( data, m2
)

6. DN                 ( data, m2) is lost

7. NCP B           retransmit (ack)
(step 2)

8. NCP A           receive (ack),
notify, send (close), close

9. NCP B           receive (close),
close

 Снова проблема возникла, потому что сообщения
одного сеанса связи сталкивались с другим сеансом связи. Это может быть
исключено выбором пары новых чисел идентификации сеанса связи для каждого
нового сеанса связи, одно для NCP A и одно для NCP B. Выбранные
числа включены во все сообщения сеанса связи, и используются, чтобы проверить,
что полученное сообщение действительно принадлежит текущему сеансу связи.
Нормальный сеанс связи протокола с тремя сообщениями следующий.

1. NCP A           send ( data, m,
x)

2. NCP B           receive (
data, m, x), deliver m, send ( ack, x, у )

3. NCP A           receive (ack, x,
y), notify, send (close, x, y), close

4. NCP B           receive ( close,
x, y ), close

  Эта модификация протокола с тремя сообщениями
исключает ошибочный сеанс связи, данный ранее, потому что сообщение, полученное
NCP A в шаге 8 не принято как подтверждение для сообщения данных,
посланного в  шаге 5. Однако, NCP B не проверяет проверку правильности (данные,
m, x) перед доставкой m (в шаге 2), что легко ведет к дублированию информации.
Если сообщение, посланное в шаге 1 отсрочено и перетранслировано, позже
прибывающее сообщение (данные, m, x)  заставляет NCP B доставлять информацию
m снова. Конечно, NCP B должен также проверять правильность сообщений, которые
он получает, перед доставкой данных. Мы рассматриваем модификацию сеанса связи
с тремя сообщениями, в котором NCP B доставляет данные в шаге 4, a не в шаге 2.
Уведомление теперь передается от NCP A перед доставкой от NCP B,
но потому что NCP B уже получил информацию, это кажется оправданным. Должно
быть обеспечено, тем не менее, что NCP B теперь доставит данные в любом случае;
в частности когда сообщение (close, x, y)  потеряно. NCP B повторяет сообщение
(ack, x, y) , на которое NCP А отвечает с сообщением (nocon, x, y) , заставляя
NCP B доставить и закрыться, как в следующем сценарии.

1. NCP A           send (data,m,x)

2. NCP B           receive ( data, m,
x ), send ( ack, x, y )

3. NCP A           receive (ack,x,y),
notify, send (close, x, y), close

4. DN                 ( close, x, y )
is lost

5. NCP B           timeout, retransmit ( ack,
x, y )

6. NCP A           receive (ack, x,
y), reply (nocon, x, y)

7. NCP B           receive (nocon,
x, y), deliver m, close

Оказалось, чтобы избегать потери информации NCP B
должен доставлять данные, даже если NCP А не подтверждает, что имеет
подключение с идентификаторами x и y. Это делает механизм проверки правильности
бесполезным для NCP B, ведя к возможности дублирования информации как в
следующем сценарии.

1. NCP A           send (data, m, x
)

2. NCP A           timeout, retransmit (
data, m, x)

3. NCP B           receive ( data, m, a:)
(sent in step 2), send (ack, x,y1 )

4. NCP A           receive ( ack, x,
y1 ), notify, send { close, x, y1 ), close

5. NCP B           receive (close, x,
yi ), deliver m, close

6. NCP B           receive (data, m,
x ) (sent in step 1), send ( ack, x, у2)

7. NCP A           receive ( ack, x,
y2), reply { nocon, x, y2)

8. NCP B           receive ( nocon,
x,y2) in reply to ( ack, x, y2 ), deliver m, close

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

1. NCP A           send ( data, m, x )

2. NCP B           receive ( data, m, x
), send ( open, x, у )

3. NCP A           receive ( open, x, у
), send ( agree, x, у )

4. NCP B           receive (agree, x,
y), deliver m, send (ack, x, y), close

5. NCP A           receive (ack, x, y),
notify, close

Возможность аварийного отказа NCP В вынуждает
обработку ошибок быть такой, что дубликат может все еще происходить, даже,
когда никакой NCP фактически не терпит крах. Сообщение об ошибках (nocon, x, y)
послано NCP В когда сообщение (agree, x, y)  получено, и никакой сеанс связи не
открыт. Предположим, что NCP A не получает сообщение (ack, x, y), даже после
несколько перепередач {agree, x, y) ; только сообщения (nocon, x, y)  получены.
Так как возможно, что NCP В потерпел крах прежде, чем он получил (agree, x, y),
NCP вынужден запустить новый сеанс связи (посылая {data, m, x}) чтобы
предотвратить потерю m! Но также возможно, что NCP В уже доставил m, и
сообщение (ack, x, y) было потеряно, тогда появляется дубликат. Возможно
изменить протокол таким образом, что NCP A уведомляет и закрывается после
получения сообщения {nocon, x, y); это предотвращает дубликаты, но может
представлять потерю, которая рассматривается даже менее желательной.

Сеанс связи c пятью сообщениями и сравнение. Beisnes [Bel76] дает протокол с пятью сообщениями,
который не теряет информацию, и это представляет дубликаты только, если NCP
фактически терпит крах. Следовательно, это – самый лучший возможный протокол,
рассматриваемый в свете того наблюдения, что никакая надежная связь не является
возможной, ранее в этом подразделе. Из-за чрезмерных накладных расходов  (пять
сообщений проходят через NCPs, чтобы передать один информационный модуль),
должно быть подвергнуто сомнению, должен ли протокол с пятью сообщениями
действительно быть предпочтен намного более простому протоколу с двумя
сообщениями. Действительно, потому что даже протокол с пятью сообщениями может
представлять дубликаты (когда сбоят NCP), уровень процесса должны иметь дело с
ними так или иначе. Так получается, что протокол c двумя сообщениями, который
может представлять дубликаты, но может быть сделан свободным от потерь, если
идентификации сеанса связи добавлены, как мы делали для протокола с тремя
сообщениями, можем также использоваться.

1.3.3 Область
исследования

Имелось продолжающееся исследование в
распределенных алгоритмах в течение последнего двух десятилетий, и значительный
прогресс был сделаны особенно в течение 80-x. В предыдущих разделах мы указали
на некоторые технические достижения, которые стимулировали исследование в
распределенных алгоритмах, а именно, разработка компьютерных сетей (и
глобальных  и локальных) и многопроцессорные компьютеры. Первоначально
исследование было очень нацелено к прикладному применению алгоритмов в
глобальных сетях, но в настоящее время разработаны четкие математические
модели, позволяющие прикладное применение результатов и методов к более широким
классам распределенных сред. Однако, исследование поддерживает плотные связи с
достижениями техники в методах связи, потому что результаты в алгоритмах часто
чувствительны к изменениям в сетевой модели. Например, доступность дешевых микропроцессоров
сделала возможным создать системы с многими идентичными процессорами, которые
стимулировали изучение " анонимных сети " (см. Главу 9).

 Имеются несколько журналов и ежегодных
конференций, которые специализируются на результатах распределенных алгоритмов
и распределенных вычислений. Некоторые другие журналы и конференции не
специализируются исключительно по этому предмету, но тем не менее содержат
много публикаций в этой области. Ежегодный симпозиум по Принципам
распределенного вычисления (PoDC) организовывался каждый год начиная с 1982 до
времени записи в Северной Америке, и слушания изданы Ассоциацией для Вычисления
Машин. Международные Симпозиумы по распределенным алгоритмам (WDAG) были проведены
в Оттаве (1985), Амстердаме (1987), Ницце (1989), Bari (1990), Delphi (1991),
Хайфе (1992), Lausanne (1993), и Terschelling (1994). С 1989, симпозиумы
проводились ежегодно и слушания были изданы Springer-Verlag в сериях Примечания
по лекциям по информатике. Ежегодные симпозиумы на теории вычисления (SToC) и
основ информатики (FoCS) покрывают все фундаментальные области информатики, и
часто несут статьи об распределенном вычислении. Слушания SToC встреч изданы
Ассоциацией для Вычисления Машин, и таковых FoCS встреч институтом IEEE. Журнал
Параллельного и Распределенного Вычисления (JPDC) и Распределенного Вычисления
издает распределенные алгоритмы регулярно, и  делает Письма по обработке информации
(IPL).

 

1.3.4 Иерархическая
структура книги

Эта книга была написана со следующими тремя
целями в памяти.

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

(2) чтобы обеспечить понимание в свойственных
возможностях и невозможности нескольких моделей системы. Воздействие
доступности глобального кадра времени изучается в Разделе 3.2 и в Главах 11 и
14. Воздействие знания процессами их идентичности изучается в Главе 9.
Воздействие требования завершения процесса изучается в Главе 8. Воздействие
сбоев процесса изучается в части 3.

(3) Представлять совокупность недавнего
современного состояния распределенных алгоритмов, вместе с их проверкой и
анализом их сложности.

Где предмет не может обрабатываться в полных
подробностях, ссылки к релевантной научной литературе даны. Материал, собранный
в книге разделен в три части: Протоколы, Фундаментальные Алгоритмы, и
Отказоустойчивость.

Часть 1: Протоколы. Эта часть имеет дело с протоколами связи, используемыми
в реализации компьютерных сетей связи и также представляет методы, используемые
в более поздних частях. В Главе 2 модель, которая будет использоваться в
большинстве более поздних глав,  представляется. Модель является, и достаточно
общей, чтобы быть подходящей для разработки и проверки алгоритмов и достаточно
плотной для доказательства результатов невозможности. Это основано на понятии
систем перехода, для которых правила доказательства свойств безопасности и
живости могут быть даны легко. Понятие причинной связи как частичного порядока
на событиях вычисления представляется, и определены логические часы.

  В Главе 3 проблема передачи сообщения между
двумя узлами рассматривается. Сначала семейство протоколов для обмена пакетами
над одиночной связью обеспечено, и доказательство правильности, по Schoone,
дано. Также, протокол по Fletcher и Watson рассматривается, правильность
которого полагается на правильное использование таймеров. Обработка этого
протокола показывается, как метод проверки может применяться к протоколам,
основанным на использовании таймеров. Глава 4 рассматривает проблему
маршрутизации в компьютерных сетях. Она сначала представляет некоторую общую
теорию относительно маршрутизации и алгоритма Toueg для вычисления
маршрутизации таблиц. Также обрабатываемый – Netchange алгоритм Tajibnapis и
доказательства правильности для этого алгоритма, данного Lamport. Эта глава
заканчивается компактными алгоритмами маршрутизации, включая интервал и
префиксную маршрутизацию. Эти алгоритмы названы компактными алгоритмами маршрутизации,
потому что они требуют только маленького количества памяти в каждом узле сети.
Обсуждение протоколов для компьютерных сетей заканчивается некоторыми
стратегиями для ухода от тупиков с промежуточным накоплением в компьютерных
сетях с коммутацией пакетов в Главе 5. стратегии основаны при определении
свободных от циклов направленных графов на буферах в узлах сети, и показано,
как такой граф может быть создан, используя только скромное количество буферов
в каждом узле.

Часть 2: Фундаментальные Алгоритмы. Эта часть представляет ряд алгоритмических
"строительных блоков", которые используются как процедуры во многих
распределенных прикладных программах, и разрабатывает теорию относительно
вычислительной мощности различных сетевых предложений. Глава 6 определяет
понятие " волновой алгоритм ", который является обобщенной схемой
посещения всех узлов сети. Волновые алгоритмы используются, чтобы распространить
информацию через сеть, синхронизировать узлы, или вычислять функцию, которая
зависит от распространения информации над всеми узлами. Поскольку это соберется
в более поздних главах, много проблем распределенного  управления могут быть
решены в соответствии с очень общими алгоритмическими схемами, в которых
волновой алгоритм используется как компонент. Эта глава также определяет
сложность времени распределенных алгоритмов и исследует время и сложность
сообщения ряда распределенных алгоритмов поиска в глубину.

Фундаментальная проблема в распределенных
системах – выбор: Выбор одиночного процесса, который должен запустить
различаемую роль в последующем вычислении. Эта проблема изучается в Главе 7.
Сначала проблема изучается для кольцевых сетей, где показано, что сложность
сообщения проблемы – O (NlogN) сообщений (на кольце N процессоров). Проблема
также изучается для общих сетей, и некоторые конструкции показываются,  к
которым алгоритмы выбора могут быть получены из волновых алгоритмов и
алгоритмов обхода. Эта глава также обсуждает алгоритм для конструкции охвата
дерева Gallager и другие.

 Вторая фундаментальная проблема – обнаружение
завершения, распознавание (процессами непосредственно) того, что
распределенное вычисление завершено. Эта проблема изучается в Главе 8. Нижняя
граница сложности решения этой проблемы доказана, и несколько алгоритмов
обсуждены подробно. Глава включает некоторые классические алгоритмы
(например.,  Dijkstra, Feijen, и Van Gasteren и Dijkstra и Scholten) и снова
конструкция дана для получения алгоритмов для этой проблемы из волновых
алгоритмов.

 Глава 9 изучает вычислительную мощность систем,
где процессы не различаются уникальными идентификаторами. Как показал Angluin,
что в этом случае много вычислений не могут быть выполнены детерминированным
алгоритмом. Глава представляет вероятностные алгоритмы, и мы исследуем какие проблемы,
могут быть решены этими алгоритмами.

 Глава 10 объясняет, как процессы системы могут
вычислять глобальное "изображение", снимок состояния системы. Такой
кадр полезен для определения свойств вычисления, типа того, произошел ли тупик,
или как далеко вычисление прогрессировало.

 В Главе 11 эффект доступности понятия
глобального времени будет изучаться. Несколько степеней синхронизма будут
определены, и будет показано, что полностью асинхронные системы могут моделировать
полностью синхронные довольно тривиальными алгоритмами. Таким образом замечено,
что предположения относительно синхронизма не влияют на совокупность функций, которые
являются вычислимыми распределенной системой. Будет впоследствии показываться,
однако, что имеется влияние на сложность связи многих проблем: чем лучше синхронизм
сети, тем ниже сложность алгоритмов для этих проблем.

Часть 3: Отказоустойчивость. В практических распределенных системах
возможность сбоя в компоненте не может игнорироваться, и следовательно важно
изучить, как хорошо алгоритм ведет себя, если компоненты терпят неудачу. Этот
предмет будет обрабатываться в последней части книги; короткое введение в
предмет дано в Главе 12. Отказоустойчивость асинхронных систем изучается в
Главе 13. Результат Fischer и других обеспечен; показывается, что детерминированные
асинхронные алгоритмы не могут справляться с даже очень скромным типом сбоя,
аварийным отказом одиночного процесса. Будет также показано, что с более
слабыми типами неисправностей можно иметь дело, и что некоторые задачи являются
разрешимыми несмотря на сбой типа аварийного отказа. Алгоритмы Bracha и Toueg
будут обеспечены: оказывается, напротив, рандомизированные асинхронные
системы,  способны справиться с приемлемо большим количеством сбоев. Таким
образом замечено, что имеет место для надежных систем (см. Главу 9), рандомизированные
алгоритмы предлагают большее количество возможностей чем детерминированные алгоритмы.

 В Главе 14 отказоустойчивость синхронных
алгоритмов будет изучаться. Алгоритмы Lamport и другие показали, что детерминированные
синхронные алгоритмы могут допустить нетривиальные сбои. Таким образом
замечено, что, в отличие от случая надежных систем (см Главу 11), синхронные
системы предлагают большее количество возможностей чем асинхронные системы.
Даже большее число неисправностей может допускаться, если процессы способны
"подписаться" на связь к другим процессам. Следовательно, выполнение
синхронизма в ненадежной системе больше усложнено, чем в надежном случае. И
последний раздел Главы 14 будет посвящен этой проблеме.

 Другой подход к надежности, а именно через
само-стабилизацию алгоритмов, сопровождается в Главе 15. Алгоритм
стабилизируется, если, независимо от начальной конфигурации, он сходится в
конечном счете к предназначенному поведению. Некоторая теория относительно
стабилизации алгоритмов будет разработана, и ряд алгоритмов стабилизации будет
обеспечен. Эти алгоритмы включают протоколы для нескольких алгоритмов графа
типа вычисления дерева поиска в глубину (как в Разделе 6.4) и вычисления таблиц
маршрутизации (как в Главе 4). Также, стабилизационные алгоритмы для передачи
данных (как в Главе 3) были предложены. Это может означать, что все
компьютерные сети могут быть выполнены, c использованием стабилизационых
алгоритмов.

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

2 Модель

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

Для того чтобы
признать выводы невозможности  (доказательство не существования алгоритма для
определенной задачи), модель должна быть очень точной. Вывод невозможности это
утверждение о всех возможных алгоритмах, разрешенных в системе, отсюда
модель должна быть достаточно точной, чтобы описать релевантные свойства для
всех допускаемых алгоритмов. Кроме того, вычислительная модель это более чем
детальное описание конкретной компьютерной системы или языка программирования.
Существует множество различных компьютерных систем, и мы хотим, чтобы модель
была применима к классу схожих систем, имеющих общие основные свойства,
которые делают их «распределенными». И наконец, модель должна быть приемлемо
компактной, потому что хотелось бы, чтобы в доказательствах учитывались все
аспекты модели. Подводя итог, можно сказать, что модель должна описывать точно
и кратко релевантные аспекты класса компьютерных систем.

Распределенные
вычисления обычно понимаются как набор дискретных событий, где каждое событие
это атомарное изменение в конфигурации (состояния всей системы). В разделе 2.1
это понятие включено в определение систем перехода, приводящих к понятию
достижимых конфигураций и конструктивному определению множества исполнений,
порождаемых алгоритмом. Что делает систему «распределенной»? То, что на каждый
переход влияет, и он в свою очередь оказывает влияние только на часть
конфигурации, в основном на локальное состояние одного процесса. (Или на
локальные состояния подмножества взаимодействующих процессов.)

Разделы 2.2 и
2.3 рассматривают следствия и свойства модели, описанной в разделе 2.1. Раздел
2.2 имеет дело с вопросом о том, как могут быть доказаны желаемые свойства
данного распределенного алгоритма. В разделе 2.3 обсуждается очень важное
понятие, а именно: каузальное отношение между событиями в исполнении. Это
отношение вызывает отношение эквивалентности, определенное на исполнениях; вычисление
это класс эквивалентности, порожденный этим отношением. Определены часы, и
представлены логические часы как первый распределенный алгоритм, обсуждаемый в
этой книге. И наконец, в разделе 2.4 будут обсуждаться дальнейшие допущения и
нотация, не включенные в основную модель.

2.1 Системы перехода и алгоритмы

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

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

Процессы в
распределенной системе сообщаются либо с помощью доступа с разделяемым
переменным либо при помощи передачи сообщений. Мы примем более
ограниченный взгляд и рассмотрим только распределенные системы, где процессы
сообщаются при помощи обмена сообщениями. Распределенные системы, где сообщение
производится посредством разделяемых переменных, будут обсуждаться в главе 15.
Читатель, интересующийся сообщением посредством разделяемых переменных, может
проконсультироваться в поворотной статье Дейкстры [Dij68] или Овицкий и Грайс
[OG76].

Сообщения в
распределенных системах могут передаваться либо синхронно, либо асинхронно.
Основной упор в этой книге делается на алгоритмы для систем, где сообщения
передаются асинхронно. Во многих случаях синхронная передача сообщений может
рассматриваться как специальный случай асинхронной передачи сообщений, как это
было продемонстрировано Чаррон-Бост и др. [CBMT92]. Подраздел 2.1.2 описывает
модель асинхронной передачи сообщений точно; в подразделе 2.1.3 модель
адаптируется к системам, использующим синхронную передачу сообщений. В
подразделе 2.1.4 кратко обсуждается справедливость.

2.1.1 Системы переходов

Система
переходов состоит из множества всех возможных состояний системы, переходов
(«ходов»), которые система совершает в этом множестве, и  подмножества
состояний, в которых системе позволено стартовать. Чтобы избежать беспорядка
между состояниями отдельного процесса и состояниями алгоритма целиком
(«глобальных состояний»), последние теперь будут называться конфигурациями.

Определение
2.1 Система переходов есть тройка S = (C, ®, I), где С это множество
конфигураций, ® это бинарное отношение
перехода на  C, и I это подмножество С начальных конфигураций.

Отношение
перехода это подмножество С х С. Вместо (g, d) Î ®
будет использоваться более удобная нотация g
® d.

Определение
2.2 Пусть S = (C, ®, I)
это система переходов. Исполнение S это есть максимальная последовательность
E = (g0, g1, g2,…),
где g0 Î I, и для всех i ³ 0, gi
® gi+1.

Терминальная
конфигурация это конфигурация g, для
которой не существует d такой, что g ® d. Нужно помнить, что последовательность E
= (g0, g1, g2,…)
с gi ® gi+1
для всех i максимальна, если она либо бесконечна, либо заканчивается в
терминальной конфигурации.

Определение
2.3 Конфигурация d достижима
из g, нотация g Þ
d, если существует последовательность
g = g0,
g1, g2, …, gk
= d c gi ® gi+1
для всех 0 £  i < k.
Конфигурация d достижима, если
она достижима из начального состояния.

2.1.2 Системы с асинхронной передачей сообщений

Распределенная
система состоит из набора процессов и коммуникационной подсистемы.
Каждый процесс является системой переходов сам по себе с той лишь оговоркой,
что он может взаимодействовать с коммуникационной подсистемой. Чтобы избежать
путаницы между атрибутами распределенной системы как целого и атрибутов
индивидуальных процессов, мы используем следующее соглашение. Термины «переход»
и «конфигурация» используются для атрибутов системы целиком, и (их эквиваленты)
термины «событие» и «состояние» используются для атрибутов процессов. Чтобы
взаимодействовать с коммуникационной системой процесс имеет не только обычные
события (упоминаемые как внутренние события), но также события
отправки и события получения, при которых сообщения воспроизводятся
и потребляются. Пусть M будет множеством возможных сообщений, и
обозначим набор мультимножеств с элементами из M через M(M).

Определение
2.4 Локальный алгоритм процесса есть пятерка (Z, I, ^i, ^s, ^r),
где Z это множество состояний, I это подмножество Z начальных
состояний, ^i это отношение
на Z x Z, и ^s
и  ^r это отношения
на Z x M x Z. Бинарное отношение ^
на Z определяется как

c ^ d Û
(c, d) Î ^i Ú $m Î M((c, m, d) Î ^s
È ^r ).

Отношения ^i , ^s , ^r соответствуют переходам
состояния, соотносящихся с внутренними сообщениями, сообщениями отправки и
сообщениями получения, соответственно. Впоследствии мы будем обозначать
процессы через p, q, r, p1, p2 и т.д., и
обозначать множество процессов системы P. Определение 2.4 служит как
теоретическая модель для процессов; конечно, алгоритмы в этой книге не
описываются только перечислением их состояний и событий, но также средствами
удобного псевдокода (см. приложение А). Исполнения процесса есть исполнения
системы переходов (Z, ^, I).
Нас, однако, будут интересовать исполнения системы целиком, и в таком
исполнении исполнения процессов координируются через коммуникационную систему.
Чтобы описать координацию, мы определим распределенную систему как систему переходов,
где множество конфигураций, отношение перехода, и начальные состояния строятся
из соответствующих компонентов процессов.

Определение
2.5 Распределенный алгоритм для набора P = {p1,
…, pN} процессов это набор локальных алгоритмов, одного для
каждого процесса в P.

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

Определение
2.6 Система переходов, порожденная распределенным алгоритмом для
процессов p1, …, pN  при асинхронной коммуникации, (где
локальный алгоритм для процесса pi это есть (Z, I, ^i, ^s, ^r)),
это S = (C, ®, I), где

 

(1) C = {(cP1,
…, cPN, M) : ("p
Î P : cp
Î Zp) и M Î M(M)}.

(2) à = (ÈpÎP àp), где àp это переходы соответствующие
изменениям состояния процесса p; àPi
это множество пар

 

(cP1,
…, cPi, …, cPN, M1), (cP1,
…, c’Pi, …, cPN, M2),

 

для которых
выполняется одно из следующих трех условий:

· 
(cPi , c’Pi ) Î ^iPi
и M1 = M2;

· 
для некоторого m Î
M, (cPi , m, c’Pi ) Î ^sPi
и M2 = M1 È
{m};

· 
для некоторого m Î
M, (cPi , m, c’Pi ) Î ^rPi
и M1 = M2 È
{m}.

 

(3) I = {(cP1,
…, cPN, M) : ("p
Î P : cp
Î Ip) Ù M = Æ}.

Исполнение
распределенного алгоритма это исполнение его, породившее систему переходов. События
исполнения выполняются явно с помощью следующей нотации. Пары (c, d) Î ^ip
называются (возможными) внутренними событиями процесса p, и
тройки в ^sp
и ^rp
называются событиями отправки и событиями получения процесса.

· 
Внутреннее событие е заданное как е = (c, d) процесса
p называется применимым в конфигурации g = (cP1, …, cP, …, cPN,
M), если cp = c. В этом случае, e(g) определяется как конфигурация (cP1,
…, d, …, cPN, M).

· 
Событие отправки e, заданное как e = (c, m, d)
процесса p называется применимым в конфигурации g = (cP1, …, cP,
…, cPN, M), если cp = c. В этом случае,
e(g) определяется как
конфигурация (cP1, …, d, …, cPN, M È {m}).

· 
Событие получения e, заданное как e = (c, m, d)
процесса p называется применимым в конфигурации g = (cP1, …, cP,
…, cPN, M), если cp = c и m Î M. В этом случае, e(g) определяется как конфигурация (cP1,
…, d, …, cPN, M \ {m}).

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

2.1.3 Системы с синхронной передачей сообщений

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

Определение
2.7 Система переходов, порожденная распределенным алгоритмом для
процессов p1, …, pN  при синхронной коммуникации, это S
= (C, ®, I), где

 

(1) C = {(cP1,
…, cPN) : "p Î P : cp Î Zp}.

(2) à = (ÈpÎP àp) È
(Èp,qÎP:p¹q  àpq),
где

· 
àPi
это множество пар

 

(cP1,
…, cPi, …, cPN), (cP1, …,
c’Pi, …, cPN),

для которых  (cPi
, c’Pi ) Î
^iPi ;

· 
àPiPj
это множество пар

 

(…, cPi,
…, cPj , …), (…, c’Pi, …, c’Pj
, …),

 

для которых существует
сообщение m Î M такое, что

 

(cPi
, m, c’Pi ) Î
^sPi  и 
(cPj , m, c’Pj ) Î ^rPj
.

 

 (3) I = {(cP1,
…, cPN) : ("p Î P : cp Î Ip)}.

Некоторые
распределенные системы допускают гибридные формы коммуникации; процессы в них
имеют коммуникационные примитивы для передачи сообщений как в синхронном так и
в асинхронном стиле. Имея две модели, определенные выше, нетрудно разработать
формальную модель для этого типа распределенных систем. Конфигурации такой
системы включают состояния процессов и набор сообщений в процессе передачи (а
именно, асинхронных сообщений). Переходы включают все типы переходов представленных
в определениях 2.6 и 2.7.

Синхронизм и
его влияние на алгоритмы. Уже было замечено, что во многих случаях
синхронная передача сообщений может рассматриваться как специальный случай
асинхронной передачи сообщений. Набор исполнений ограничен в случае синхронной
передачи сообщений исполнениями, где за каждым событием отправки немедленно
следует соответствующее событие приема [CBMT92]. Мы поэтому рассматриваем
асинхронную передачу сообщений как более общую модель, и будем разрабатывать
алгоритмы в основном для этого общего случая.

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

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

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

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

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

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

2.1.4 Справедливость

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

Определение
2.8 Исполнение справедливо в слабом смысле, если нет события применимого
в бесконечно многих последовательных конфигурациях без появления в исполнении.
Исполнение справедливо в сильном смысле, если нет события применимого в
бесконечно многих конфигурациях без появления в исполнении.

Возможно
включить условия справедливости в формальную модель явно, как это сделано Манна
и Пнули [MP88]. Большинство алгоритмов, с которыми мы имеем дело в этой книге,
не полагаются на эти условия; поэтому мы решили не включать их в модель, а
устанавливать эти условия явно, когда они используются для конкретного
алгоритма или проблемы. Также, существует спор, приемлемо ли включать
предположение справедливости в модели распределенных систем. Было выдвинуто
утверждение, что предположение справедливости не должны производиться, более
того  алгоритмы не должны разрабатываться с учетом этих предположений.
Дискуссия по некоторым запутанным вопросам, относящимся к предположению
справедливости может быть найдена в [Fra86].

2.2 Доказательство свойств систем перехода

Рассматривая
распределенный алгоритм для некоторой проблемы, необходимо продемонстрировать,
что алгоритм есть корректное решение этой проблемы. Проблема указывает, какие
свойства требуемый алгоритм должен иметь; должно быть показано, что решение
обладает этими свойства. Вопрос проверки распределенных алгоритмов получил
значительное внимание и есть большое количество статей, обсуждающих формальные
методы проверки; см. [CM88, Fra86, Kel76, MP88]. В этом разделе обсуждаются
некоторые простые, но часто используемые методы для демонстрации правильности
распределенных алгоритмов. Эти методы полагаются только на определение системы
переходов.

Многие из
требуемых свойств распределенных алгоритмов попадают в один из двух типов:
требования безопасности и требования живости. Требования безопасности
накладывают ограничение, что определенное свойство должно выполняться для
каждого исполнения системы в каждой конфигурации, достигаемой в этом исполнении.
Требования живости определяют, что определенное свойство должно выполняться для
каждого исполнения системы в некоторых конфигурациях, достигаемых в этом
исполнении. Эти требования могут также встречаться в ослабленной форме,
например, они могут удовлетворяться с некоторой фиксированной вероятностью над
множеством возможных исполнений. Другие требования к алгоритмам могут включать
ограничения, которые основываются только на использовании некоторого данного
знания (см. подраздел 2.4.4), что они гибки по отношен ию к нарушениям в
некоторых процессах (см. часть 3), что процессы равны (см. главу 9), и т.д.

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

2.2.1 Свойства безопасности

Свойство
безопасности алгоритма это свойство в форме «Утверждение P истина в
каждой конфигурации каждого исполнения алгоритма». Неформально это
формулируется как «Утверждение Р всегда истина». Основной метод для того,
чтобы показать, что утверждение Р всегда истина, это продемонстрировать,
что Р инвариант согласно следующим определениям. Нотация P(g), где g
это конфигурация, есть булево выражение, чье значение истина, если Р
выполняется в g, и ложь в противном
случае.

Определения
зависят от данной системы переходов S = (C, à, I). Далее, мы будем писать {P} à {Q}, чтобы обозначить, что
для каждого перехода g à d
(системы S), если Р(g) то
Q(d). Таким образом {P} à {Q} означает, что, если Р
выполняется перед любым переходом, то Q выполняется после этого
перехода.

Определение
2.9 Утверждение Р инвариант системы S, если

(1)  для
всех g Î I, и

(2)  {P}
à {P}.

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

Теорема 2.10
Если Р это инвариант системы S, то Р выполняется для каждой конфигурации
каждого исполнения системы S.

Доказательство.
Пусть Е = (g0, g1, g2,
…) исполнение системы S. Будет показано по индукции, что Р(gi) выполняется для каждого i.
Во-первых, Р(g0) выполняется,
потому что g0 Î I и по первому предложению
определения 2.9. Во-вторых, предположим P(gi
) выполняется и gi à gi+1
есть переход, который встречается в E. По второму предложению определения 2.9
P(gi+1) выполняется, что и
завершает доказательство.

И наоборот,
утверждение, которое выполняется в каждой конфигурации каждого исполнения, есть
инвариант (см. упражнение 2.2). Отсюда не каждое свойство безопасности может
быть доказано применением теоремы 2.10. В этом случае, однако, каждое
утверждение, которое всегда истинно, включено в инвариант; отсюда может быть
показано, применением следующей теоремы, что утверждение всегда истинно. (Нужно
помнить, однако, что часто очень трудно найти подходящий инвариант Q, к
которому можно применить теорему.)

Теорема 2.11
Пусть Q будет инвариантом системы S и положим Q Þ P (для каждого g Î
С). Тогда Р выполняется в каждой конфигурации каждого исполнения системы S.

 

Доказательство.
По теореме 2.10, Q выполняется в каждой конфигурации, и так как Q включает P,
то P выполняется в каждой конфигурации также.

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

Определение
2.12 Пусть S будет системой переходов и P, Q будут утверждениями. Р
называется Q-производным, если

 

(1)  для
всех g Î I, Q(g) Þ Р(g); и

(2)  {Q
Ù Р} à {Q Þ Р}.

Теорема 2.13 Если Q есть инвариант и Р
– Q-производное, то Q Ù P есть
инвариант.

Доказательство.
Согласно определению 2.9, должно быть показано, что

(1)  для
всех g Î
I, Q(g) Ù
Р(g); и

(2)  {Q Ù Р} à
{Q Ù Р}.

Т.к. Q это
инвариант, Q(g) выполняется для всех g Î
I, и т.к. для всех g Î I, Q(g) Þ Р(g), P(g)
выполняется для всех g Î I. Следовательно, Q(g) Ù
P(g) выполняется для всех g Î
I.

Предположим g à
d и Q(g)
Ù Р(g). Т.к. Q это инвариант, Q(d)
выполняется, и т.к. {Q Ù
P} à {Q Þ Р}, Q(d) Þ Р(d), откуда Р(d) вытекает. Следовательно, Q(d) Ù
Р(d) выполняется.

Примеры
доказательства безопасности, основывающиеся на материале данного раздела,
представлены в разделе 3.1.

2.2.2 Свойства живости

Свойство
живости алгоритма это свойство в форме «Утверждение Р истина в некоторой
конфигурации каждого исполнения алгоритма». Неформально это формулируется как
«Утверждение Р в конечном счете истина». Основные методы, используемые, чтобы
показать, что Р в конце концов истина – это нормирующие функции и беступиковость
(или правильное завершение). Более простой метод может быть использован
для алгоритмов, в которых разрешаются только исполнения с фиксированной,
конечной длиной.

Пусть S будет системой переходов и Р – предикат. Определим term как предикат, который истина во всех терминальных
конфигурациях и ложь во всех нетерминальных конфигурациях. Мы сначала предположим
ситуации, где исполнение достигает терминальной конфигурации. Обычно
нежелательно, чтобы такая конфигурация достигалась, в то время, как «цель» Р не
была достигнута. Говорят, что в этом случае имеет место тупик. С другой
стороны, завершение позволено, если цель была достигнута, в этом случае говорят
о правильном завершении.

Определение
2.14 Система S завершается правильно (или
без тупиков), если предикат (term Þ Р) всегда истинен в системе S.

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

Определение
2.15 Частичный порядок (W, <) является обоснованным, если в нем нет бесконечной
убывающей последовательности

w1 > w2 > w3 … .

Примеры
обоснованных множеств, которые будут использоваться в этой книге – это
натуральные числа с обычным порядком, и n-кортежи
натуральных чисел с лексикографическим порядком (см. раздел 4.3). Свойство, что
обоснованное множество не имеет бесконечной убывающей последовательности, может
использоваться, чтобы показать, что утверждение Р в конечном счете истина. К
этому моменту должно быть показано, что существует функция f 
из C в обоснованное множество W такая,
что в каждом переходе значение f убывает или Р
становится истиной.

Определение
2.16  Пусть даны система переходов S и
утверждение Р. Функция f из С в обоснованное
множество W называется нормирующей функцией (по
отношению к Р), если для каждого перехода g 
à d , f(g) > f(d) или Р(d).

 

Теорема 2.17
Пусть даны система переходов S и
утверждение Р. Если S завершается правильно и
нормирующая функция f (w.r.t
Р) существует, то Р – истина в некоторой конфигурации каждого
исполнения системы S.

 

Доказательство.
Пусть Е = (g0, g1, g3,
…) – исполнение системы S. Если Е конечно, его
последняя конфигурация является терминальной, и т.к. term Þ Р всегда
истина в системе S, то Р выполняется в этой конфигурации.
Если Е бесконечно, пусть E’ будет самым длинным
префиксом Е, который не содержит  конфигураций, в которых Р истина, и пусть s будет последовательностью (f(g0 ), f(g1), …) для всех конфигураций gi,
которые появляются в Е’. В зависимости от выбора Е’ и свойства f, s может
быть убывающей последовательностью, и отсюда,  по обоснованности W, s конечна.  Это подразумевает
также, что Е’ – конечный префикс (g0, g1,
…, gk ) исполнения Е. В
зависимости от выбора Е’, Р(gk+1) выполняется.

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

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

Теорема 2.18
Если S завершается правильно и есть число К
такое, что каждое исполнение содержит по крайней мере К переходов, то Р истина
в некоторой конфигурации каждого исполнения.

Рис. 2.1 Пример пространственно-временной диаграммы

2.3 Каузальный порядок событий и логические часы

Взгляд на
исполнения как последовательности переходов естественным образом порождает
понятие времени в исполнениях. Говорят, что переход а появляется раньше
перехода b, если a встречается
в последовательности перед b. Для исполнения Е = (g0, g1,
…) определим ассоциированную последовательность событий Е’=(е0,
е1, …), где еi – это событие, при котором конфигурация
изменяется из gi  в gi+1. Заметьте, что каждое
исполнение определяет уникальную последовательность событий этим путем.
Исполнение может быть визуализировано в пространственно-временной
диаграмме, рисунок 2.1, которой, представляет пример. В такой диаграмме,
горизонтальная линия нарисована для каждого процесса, и каждое событие нарисовано
точкой на линии процесса, где оно имеет место. Если сообщение m послано при
событии s и получено при событии r, стрелка рисуется от
s к r. Говорят, что события s и r соответственные в этом случае.

Как мы увидим в
подразделе 2.3.1, события распределенного исполнения могут иногда быть взаимно
обменены без воздействия на последующие конфигурации исполнения. Поэтому
понятие времени как абсолютного порядка на событиях исполнения не приемлемо для
распределенных исполнений, и вместо этого представляется понятие каузальной
зависимости. Эквивалентность исполнений при переупорядочивании событий
изучается в подразделе 2.3.2. Мы обсуждаем в подразделе 2.3.3 как могут быть
определены часы для измерения каузальной зависимости (а не времени), и
представляем логические часы Лампорта, важный пример таких часов.

2.3.1 Независимость и зависимость событий

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

Теорема 2.19
Пусть g будет
конфигурацией распределенной системы (с асинхронной передачей сообщений) и
пусть ер и еq будут событиями различных процессов р и q, применимых в g.
Тогда ер применимо в еq(g), еq применимо в ер(g), и ер(еq(g)) = еq(ер(g)).

Доказательство.
Чтобы избежать анализа случаев, которые есть посылка, получение, или внутренние
события, мы представим каждое событие однородной нотацией (с, х, у, d). Здесь с и d обозначают состояние процесса до и после
события, х – набор сообщений, полученных во время события, и у – набор сообщений,
посланных во течение события. Таким образом, внутренне событие (с, d)
обозначается как (c,Æ,Æ,d), событие отправки (с, m, d)
обозначается как (с, Æ, {m}, d), и событие приема (с, m, d) – (c, {m}, Æ, d). В этой
нотации, событие е = (с, x, y, d) процесса p применимо
в конфигурации g = (Сp1, …, Cp, …, СрN, M), если ср  = с и x Í M. В этом
случае

е(g) = (Сp1, …, d, …, (M \ x) È у).

Теперь
предположим ер = (bp, xр, ур, dp)
и еq = (bq, xq, уq, dq)
применимы в

g    
= (…, ср, …, сq, …, M),

то есть ср  = bp, cq = bq, xp 
Í M, и xq Í M. Важное наблюдение состоит в том,
что хр и xq разделены, сообщение в xp (если
есть такое) имеет назначением р, в то время как сообщение в хq (если
есть такое) имеет назначением q.

Запишем gр = ер(g), и запомним что

gр  = (…, dp,
…, cq, …, (M \ xp ) È ур ).

Так как xq 
Í M и xq  Ç хр  = Æ, следует, что хq Í (M \ xp  È ур ), и отсюда еq
 применимо в gр. Запишем gpq  = eq(gр), и
запомним, что

gрq 
= (…, dp, …, dq, …, ((M \ xp
È ур ) \ xq ) È
уq ).

С помощью
симметричного аргумента может быть показано, что ер применимо в gq = eq(g). Запишем gqp 
= ep(gq), и запомним, что

gqp  =
(…, dp, …, dq, …, ((M \ xq
È уq ) \ xp ) È
уp ).

Так как M – мультимножество сообщений, xp
Í M, и xq Í M,

((M \ xp È
ур ) \ хq  È
уq ) = ((M \ xq È уq ) \ xp 
È ур ),

и отсюда gpq = gqp .                                                                                                                            

Пусть ер
и еq будут двумя событиями, которые появляются последовательно в
исполнении, т.е. исполнение содержит подпоследовательность

…,
g, ер(g), еq(ер(g)), …

для некоторых g. Посылка теоремы 2.19
применима к этим событиям за исключением следующих двух случаев.

(1)  p = q; или

(2)  ер
– событие отправки, и еq  – соответствующее событие получения.

В самом деле,
теорема явно утверждает, что p и q должны
быть различными, и если еq  получает сообщение, посланное в ер,
событие отправки не применимо в начальной конфигурации события ep, как требуется. Таким образом, если одно из
этих двух утверждений истина, события не могут появляться в обратном порядке,
иначе они могут встречаться в обратном порядке и кроме того иметь результат в
одной конфигурации. Запомните, что с глобальной точки зрения переходы не могут
быть обменены, потому что (в нотации теоремы 2.19) переход из gр в gpq отличается от перехода из g в gq.
Однако, с точки зрения процесса эти события неразличимы.

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

Определение
2.20 Пусть Е – исполнение. Отношение í, называемое каузальным порядком, на событиях исполнения
есть самое малое отношение, которое удовлетворяет

(1)  Если
е и f – различные события одного процесса и е
появляется перед f, то е í f.

(2)  Если
s – событие отправки и r
– соответствующее событие получения, то s í r.

(3)  Отношение
í  транзитивно.

 

Мы пишем а í= b, чтобы
обозначить (а í b Ú а = b). Так как í=
есть частичный порядок, могут существовать события а и b,
для которых ни а í= b ни b í=
а не выполняется. Говорят такие события конкурирующие, в нотации а || b. На рисунке 2.1, b || f, d || i, и
т.д.

Каузальный
порядок был впервые определен Лампортом [Lam78] и
играет важную роль в рассуждениях, относящихся к распределенным алгоритмам. Определение
í подразумевает существование каузальной
цепочки между каузально связанными событиями. Этим мы подразумеваем, что а í b включает
существование последовательности а = е0 , е1 , …, ек 
= b такой, что каждая пара последовательных событий в
цепочке удовлетворяет либо (1), либо (2) в определении 2.20. Каузальная цепочка
может быть даже выбрана так, что каждая пара, удовлетворяющая (1), есть
последовательная пара событий в процессе, где они встречаются, т.е., нет
событий между ними. На рисунке 2.1 каузальная цепочка между событием а и
событием l есть последовательность а, f,
g, h, j, k, l.

2.3.2 Эквивалентность исполнений:
вычисления

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

Пусть f = (f0 , f1 , f2 ,…) будет
последовательностью событий. Эта последовательность – последовательность
событий относящихся к исполнению F = (d0,
d1, d2, …), если для каждого i, fi
применимо в di и fi (di)
= di+1. В этом случае F называется включенным исполнением последовательности
f. Мы хотели бы, чтобы F уникально
определялась последовательностью f, но это не всегда
так. Если для некоторого процесса p нет события в p, включенного в f, то состояние
процесса p может быть произвольным начальным
состоянием. Однако, если f содержит по крайней мере
одно событие из р, то первое событие в р, скажем (с, х, у, d),
определяет, что начальное состояние процесса р будет с. Поэтому, если f содержит по крайней мере одно событие в каждом процессе, d0 уникально определено, и это
определяет целое исполнение уникально.

Теперь пусть Е
= (g0, g1, g2,
… ) будет исполнением с ассоциированной последовательностью событий Е’ = (е0 , е1 , е2 , …) и
положим, что f –перестановка из Е’.
Это означает, что существует перестановка s
натуральных чисел (или множества {0, …, k-1}, если Е – конечное исполнение с
k событиями) таких, что fi = еs(i).
Перестановка (f0 , f1 , f2 ,
…) событий из Е согласующаяся с каузальным порядком, если fi í=
fj подразумевает i £ j,
т.е., если нет события, которому предшествует в последовательности событие,
которому оно само каузально предшествует.

Теорема 2.21
Пусть f = (f0 , f1 , f2
, …) – перестановка событий из Е, которая согласуется с каузальным
порядком исполнения Е. Тогда f определяет уникальное исполнение F, начинающееся в начальной конфигурации из Е. F имеет столько же событий сколько и Е, и если Е конечно, то
последняя конфигурация из F такая же как и
последняя конфигурация из Е.

 

Доказательство.
Конфигурации из F строятся одна за другой, и чтобы построить
di+1 достаточно показать,
что fi применимо в di.
Возьмем d0 = g0.

Предположим,
что для всех j < i, fj  применимо
в конфигурации dj и dj+1 = fj (dj ).
Пусть di = (cp1 , …, cpN , M) и пусть fi =(c, x, y, d) будет событие в процессе р, тогда
событие fi  применимо в di, если сp
= c и х Í
М.

Чтобы показать,
что сp = c нужно различать два случая. В обоих случаях мы должны
помнить, что каузальный порядок исполнения Е абсолютно упорядочивает
события в процессе р. Это подразумевает, что события в процессе р появляются в
точно таком же порядке и в f и в Е’.

Случай 1:
fi  – первое событие в р из f, тогда ср – это начальное состояние р. Но тогда fi – также первое событие в р из Е’, что подразумевает, что с – это начальное состояние р.
Следовательно, с = ср.

Случай 2:
fi – не первое событие в р из f. Пусть последнее событие в р из f перед
fi будет fi’  = (c’, x’, y’, d’),
тогда ср = d’. Но тогда fi’ также последнее событие в р
перед fi из Е’, что подразумевает, что с = d’.
Следовательно, с = ср.

Чтобы показать,
что х Í М мы должны помнить, что
соответствующие события приема и посылки встречаются в одном порядке и в f  и в Е’. Если fi  не
событие посылки, то х = Æ и х Í М выполняется тривиально. Если fi – это событие посылки, пусть fi
будет соответствующим событием посылки. Так как fj
í fi
, j < i выполняется, т.е., событие посылки предваряет fi в f, следовательно, х Í М.

Мы сейчас
показали, что для каждого i, fi применимо в di, и di+1 может быть взято как fi(di). Мы должны, наконец, показать, что последние конфигурации
из F и Е совпадают, если Е конечно. Пусть gk будет последней конфигурацией
из Е. Если Е’ не содержит события в р, то  состояние р
в gk равно его начальному
состоянию. Так как f также не содержит события в р, то
состояние р в dk также равно
начальному состоянию, отсюда состояние р в dk
равняется его состоянию в gk.
Иначе, состояние р в gk есть
состояние после последнего события в р из Е’. Это также
последнее событие в р из f, так что это также состояние
р в dk.

Сообщения в
процессе передачи в gk есть
такие сообщения, для которых событию посылки нет соответствующего события
получения в Е’. Но так как Е’ и f содержат один и тот же набор событий, те же сообщения в
процессе передачи в последней конфигурации из F.           

Рис. 2.2 Пространственно-временная диаграмма эквивалентная рис. 2.1

Исполнения F и Е имеют один набор событий, и каузальный порядок этих
событий – один и тот же для Е и F. Поэтому, также, в
этом случае Е – это перестановка событий из F, которая
согласуется с каузальным порядком исполнения F. Если
применить условие теоремы 2.21, мы можем сказать, что Е и F
– эквивалентные исполнения, что обозначается как E ~ F.

Рис. 2.2
показывает временную диаграмму исполнения, эквивалентного исполнению,
изображенному на рис. 2.1. Эквивалентные временные диаграммы могут быть
получены с помощью «трансформаций резиновой ленты» [Mat89c].
Полагая, что временная ось процесса может быть сжата и растянута пока стрелки
сообщений продолжают указывать направо, рис. 2.1 может быть деформирован до
рис. 2.2.

Хотя
изображенные исполнения эквивалентны и содержат одинаковый набор событий, они
не могут содержать одинаковый набор конфигураций. Рис. 2.1 содержит
конфигурацию (g”),
в которой сообщение, посланное в событии е и сообщение, посланное в событии l, передаются одновременно . Рис. 2.2 не содержит такой
конфигурации, потому что сообщение, посланное в событии l,
получено перед свершением события е.

Глобальный
наблюдатель, кто имеет доступ к действительной последовательности событий,
может различать два эквивалентных исполнения, т.е. может наблюдать либо одно,
либо другое исполнение. Однако, процессы не могут различать две эквивалентных
исполнения, т.к. для них невозможно решить, какое из двух исполнений имеет
место. Это иллюстрируется следующим. Предположим, что мы должны решить будут ли
посылаться сообщения в событии е и будут в передаче одновременно. Существует булевская
переменная sim в одном из процессов, которая должна
установлена в истину, если сообщения были в передаче одновременно, и ложь
иначе. Таким образом, в последней конфигурации рис. 2.1 значение sim – истина, и в последней конфигурации на рис 2.2 значение
– ложь. По теореме 2.21, конфигурации равны, что показывает, что требуемое
присваивание sim невозможно.

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

Определение
2.22 Вычисление распределенного алгоритма – это класс эквивалентности
(при ~) исполнений алгоритма.

Не имеет смысла
говорить о конфигурациях вычисления, потому что различные исполнения вычисления
могут не иметь одних и тех же конфигураций. Имеет смысл говорить о наборе
событий вычисления, потому что все исполнения вычисления состоят из одного и
того же набора событий. Также, каузальный порядок событий определен для
вычисления. Мы будем называть вычисление конечным, если его исполнения конечны.
Все исполнения вычисления начинаются в одной конфигурации и, если вычисление
конечно, завершаются в одной конфигурации (теорема 2.21). Эти конфигурации
называются начальными и конечными конфигурациями вычисления. Мы будем определять
вычисление с помощью частично упорядоченного множества событий, принадлежащих
ему.

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

Факт 2.23
Пусть (Х, <)  будет частичным порядком и
а, b Î
Х удовлетворяют b ³ a.
Существует линейное расширение <1 операции < такое, что а <1 b.

 

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

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

Теорема 2.24
Пусть g будет конфигурацией
распределенной системы с синхронной передачей сообщений и пусть е1
будет переходом процессов р и q, и е2
будет переходом процессов r и s, отличных от р и q, такие,
что и е1 и е2 применим в g. Тогда е1 применим в е2(g), е2 применим в е1(g), и е1(е2(g)) = е2(е1(g)).

Доказательство
этой теоремы, которое основывается на тех же аргументах, что и доказательство
теоремы 2.19, оставлено для упражнения 2.9. Понятие казуальности в синхронных
системах может быть определено подобно определению 2.20. Интересующегося
читателя можно отослать к [CBMT92].
Теорема 2.21 также имеет своего двойника для синхронных систем.

2.3.3 Логические часы

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

Определение
2.25 Часы есть функция Q,
действующая из событий на упорядоченное множество такое, что

 

a
í b Þ Q(а) < Q(b).

Далее в этом разделе обсуждаются некоторые примеры
часов.

(1)  Порядок
в последовательности. В исполнении Е, определенном последовательностью
событий (е0, е1, е2, …), множество Qg(еi) = i. Таким образом,
каждое событие помечается своей позицией в последовательности событий.

Эта функция может использоваться глобальным наблюдателем системы, кто
имеет доступ к порядку, в котором происходят события. Однако, невозможно
наблюдать этот порядок внутри системы, или, иначе говоря, Qg не может быть вычислена распределенным алгоритмом. Это следствие
теоремы 2.19. Предположим, что некоторый распределенный алгоритм сохраняет
значение Qg(еi) = i  для события еi (что удовлетворяет посылке
теоремы). В эквивалентном исполнении, в котором это событие меняется со
следующим событием, и следовательно имеет другое значение Qg, то же значение i сохраняется в процессе. Говоря другими словами, Qg определено для исполнений, но
не для вычислений.

(2)  Часы
реального времени. Имеется возможность расширить модель, что
является предметом обсуждения этой главы, с помощью снабжения каждого процесса
аппаратными часами. Этим путем возможно записывать для каждого события реальное
время, в которое оно произошло. Полученные числа удовлетворяют определению
часов.

Распределенные системы с часами реального времени не удовлетворяют
определению 2.6, потому что физические свойства часов синхронизируют изменения
состояний в разных процессах. Время идет во всех процессах, и это порождает
переходы, которые меняют состояние (а именно, считыванием часов) всех
процессов. Оказывается, что эти «глобальные переходы» ужасно меняют  свойства
модели. В самом деле, теорема 2.19 больше не действует, если приняты часы реального
времени. Распределенные системы с часами реального времени используются на практике,
однако, и они будут рассматриваться в этой книге (см. раздел 3.2) и главы 11 и
14.

 

Алгоритм
2.3 Логические часы Лампорта

(3)  Логические
часы Лампорта. Лампорт [Lam78] представил часовую
функцию, которая приписывает событию а длину k самой
длинной последовательности (е1, …, еk) событий,
удовлетворяющей

е1
í е2
í … íеk = a

В самом деле,
если а í b,
эта последовательность может быть расширена, чтобы показать, что QL(a)  < QL(b). Значение QL может быть вычислено для
каждого события распределенным алгоритмом, базируясь на следующих отношениях.

(а) Если а
есть внутреннее событие или событие посылки, и а’ – предыдущее
событие в том же процессе, то QL(a) = QL(a’) + 1.

(b) Если а – событие получение, а’ –
предыдущее событие в том же процессе, и b –событие посылки,
соответствующее а, то QL(a) = max(QL(a’), QL(b)) + 1.

В обоих
случаях QL(a’)
предполагается нулевым, если а – первое событие в процессе.

Чтобы вычислить значения часов распределенным алгоритмом, значение
часов последнего события процесса р сохраняется в переменной qр (инициализируемой в 0). Для того, чтобы вычислить значение часов события
получения, каждое сообщение m содержит значение часов qm события
е, при котором оно было послано. Логически часы Лампорта даны как алгоритм 2.3.
Для события е в процессе р, QL(е)
есть значение qр сразу же
после появления е, т.е. в момент, когда происходит изменение состояния процесса
р. Оставлена для упражнения демонстрация того, что с этим определением QL является часами.

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

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

a í b Û Q(а)
< Q(b).                                                    (2.1)

Существование
конкурирующих событий подразумевает, что область таких часов (множество Х) –
не-полностью-упорядоченное множество.

В векторных
часах Маттерна [Mat89b] X = NN, т.е. Qv(a) есть вектор длины N.
Вектора длины n естественным образом упорядочены
векторным порядком, определенным следующим образом:

(а1,
…, аn) £v (b1,
…, bn) Û "i (1 £ i £ n) : ai £ bi.                               (2.2)

(Векторный
порядок отличается от лексикографического порядка, определенного в упражнении
2.5, последний порядок  абсолютен). Часы, определяемые Qv(a) = (а1,
…, аN), аi
– это число событий е в процессе р1, для которого е í а. Как и часы Лампорта, эта функция
может быть вычислена распределенным алгоритмом.

Чаррон-Бост [CB89] показал, что невозможно использовать более короткие
векторы (с векторным порядком как в (2.2)). Если события произвольного исполнения
из N процессов отображаются на вектора длины n таких, что (2.1) удовлетворяется, то n ³ N.

2.4 Дополнительные допущения, сложность

Определений
сделанных до сих пор в этой главе достаточно, чтобы развивать оставшиеся главы.
Определенная модель служит как основа для представления и проверки алгоритмов,
так и для доказательств невозможности для решения распределенных проблем. В
различных  главах используются дополнительные допущения и нотация, если
требуется.  Этот раздел обсуждает некоторую терминологию, которая также
общеупотребительна в литературе по распределенным алгоритмам. До сих пор, мы
моделировали коммуникационную подсистему распределенной системы набором
сообщений, находящихся в данный момент в процессе передачи. Далее, мы будем
предполагать, что каждое сообщение может передаваться только одним процессом,
называемым  назначением сообщения. В общем, не обязательно чтобы каждый процесс
мог посылать сообщения каждому другому процессу. Вместо этого, для каждого
процесса определено подмножество других процессов (называемых соседями
процесса), к которым он может посылать сообщения. Если процесс р может посылать
сообщения  процессу q, говорят, что существует канал
от р до q. Если не утверждается обратное,
предполагается, что каналы двунаправленные, то есть, тот же канал позволяет
посылать q сообщения процессу p.
Канал, который осуществляет только однонаправленный трафик от р к q, называется однонаправленным (или  направленным)
каналом от р до q.

Набор процессов
и коммуникационная подсистема также упоминается как сеть. Структура
коммуникационной подсистемы часто представляется как граф G = (V, E), в котором вершины – это процессы, и ребра между
двумя процессами существуют, если и только если канал существует канал между
двумя процессами. Система с однонапрвленными каналами может подобным образом
представлена направленными графом. Граф распределенной системы также называется
ее сетевой топологией.

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

(1)  Кольца.
N-вершинное кольцо – граф
на вершинах от v0  до vN-1
c ребрами v0vN-1
(индексы – по модулю N). Кольца часто используются для
распределенного управления вычислениями, потому что они просты. Также,
некоторые физические сети, такие как Token Rings [Tan88,
раздел 3.4], распределяют узлы в кольцо.

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

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

(4)  Клики.
Клика – это сеть, в которой ребро существует между любыми двумя вершинами.

(5) 
Гиперкубы. Гиперкуб – это граф HCN = (V, E) на N = 2n
вершинах. Здесь V – множество битовых строк
длины n:

V = {(b0 , …, bn-1) : bi Î {0, 1}},

и ребро существует между двумя вершинами b
и с, тогда и только тогда, когда битовые строки b
и с различаются точно на один бит. Имя гиперкуба относится к графическому
представлению сети как n-размерного куба, углы которого
– вершины.

Рис. 2.4 Примеры часто
используемых топологий

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

2.4.2 Свойства каналов

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

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

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

Утеря сообщения имеет место, когда сообщение посылается, но
никогда не принимается. Это может быть смоделирована переходом, который удаляет
сообщение из М. Искажение сообщение встречается, когда полученное
сообщение отличается от посланного сообщения. Это может быть смоделировано
переходом, который меняет одно сообщение из М. Дублирование сообщения
появляется, если сообщение принимается более часто, чем оно посылалось. Это
может быть смоделировано переходом, который копирует сообщение из М. Порождение
сообщения, встречается, когда сообщение получено, но никогда не было послано,
это моделируется переходом, который вставляет сообщение в М.

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

Fifo каналы могут быть представлены в модели
определения 2.6 при помощи замены набора М на множество очередей, одной
для каждого канала. Отправка осуществляется добавлением сообщения к концу
очереди, и событие получения удаляет сообщение с головы. Когда предполагаются
каналы fifo, появляется новый тип коммуникационных
сбоев, а именно, переупорядочивание сообщений в канале. Это может быть
смоделировано переходом, который обменивает два сообщения в очереди.

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

Более слабое допущение было предложено Ахуджа [Ahu90].
Выталкивающий канал – это канал, который соблюдает порядок только
сообщений, для которых это было указано отправителем. Могут быть также
определены более сильные допущения. Шипер и др. [SES89]
определили каузально упорядоченную доставку сообщений, как описывается
далее. Если р1 и р2  посылают сообщения m1
и m2 процессу q в
событиях е1 и е2 и е1 í е2 , то q получает m1 перед m2 .
Иерархия допущений доставки, состоящая из полного асинхронизма, каузально упорядоченной
доставки, fifo, и синхронных коммуникаций, обсуждалась
Чаррон-Бостом и др. [CBMT92].

(3)  Емкость
канала. Емкость – это число сообщений, которое может передаваться по
каналу одновременно. Канал полон в каждой конфигурации, в которой он
действительно содержит количество сообщений, равное его емкости. Событие
посылки применимо, только если канал не полон.

Определение 2.6 моделирует каналы с неограниченной емкостью, т.е.
каналы, которые никогда не наполняются. В этой книге всегда будет
предполагаться, что емкость каналов не ограничена.

 

2.4.3 Допущения реального времени

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

Часы реального
времени могут быть встроены при помощи снабжения каждого процесса переменной
часов реального времени. Течение реального времени моделируется переходом,
который передвигает вперед часы каждого процесса, см. раздел 3.2. Обычно,
принимается ограничение на время передачи сообщения (время между отправкой и
получением сообщения) вкупе с доступностью часов реального времени. Это
ограничение может быть также включено в общую модель системы переходов.

Если не
утверждается обратное, допущения реального времени не делаются в этой книге,
т.е. мы предполагаем полностью асинхронные системы и алгоритмы.
Допущения отсчета времени будут использованы в разделе 3.2, главе 11 и главе
14.

2.4.4 Знания процессов

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

(1)  Топологическая
информация. Информация о топологии включает: количество процессов, диаметр
графа сети, и топологию графа. Говорят, что сеть имеет чувство направления,
если согласующаяся с направлениями разметка ребер в графе известна процессам
(см. дополнение Б).

(2)  Идентичность
процессов. Во многих алгоритмах требуется, чтобы процессы имели уникальные
имена (идентификаторы), и чтобы каждый процесс знал свое собственное имя
изначально. Тогда предполагается, что процессы содержат переменную, которая
инициализируется этим именем (т.е. различным для каждого процесса). Дальнейшие
допущения могут быть сделаны касательно множества, из которого выбираются
имена, – что имена линейно упорядочены или  что они (положительные) целые. Если
не утверждается обратное, в этой книге всегда будем предполагать, что процессы
имеют доступ к их идентификаторам, в этом случае система называется именованной
сетью. Ситуации, где это не так (анонимные сети) будут исследованы в
главе 9.

(3)  Идентификаторы
соседей. Если процессы различаются уникальным именем, то возможно предположить,
что каждый процесс знает изначально имена соседей. Это допущение называется знание
соседей и, если не утверждается обратное, не будет делаться. Имена
процессов могут быть полезными для цели адресации сообщений. Имя назначения
сообщения дается, когда сообщение посылается с прямой адресацией. Более
сильные допущения состоят в том, что каждый процесс знает весь набор имен
процессов. Более слабое допущение состоит в том, что процессы знают о существовании,
но не знают имен своих соседей. Прямая адресация не может использоваться в этом
случае, и процессы используют локальные имена для их каналов, когда хотят
адресовать сообщение, что называется непрямой адресацией. Прямая и
непрямая адресация показана на рис. 2.5. Прямая адресация использует идентификатор
процесса как адрес, в то время как непрямая адресация процессов р, r и s использует различные имена (а, b и c, соответственно), чтобы адресовать сообщения в
назначение q.

Рис. 2.5 Прямая
(а) и непрямая (b) адресация

2.4.5 Сложность распределенных алгоритмов

Самое важное
свойство распределенного алгоритма – его правильность: он должен удовлетворять
требованиям, налагаемым проблемой, что алгоритм

3
Протоколы Связи

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

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

Протоколы, обсуждаемые в этой главе разработаны для
различных уровней в иерархии протокола, типа модели OSI (Подраздел 1.2.2). Они
включены в эту книгу по различным причинам; первый протокол полностью
асинхронный, в то время как второй протокол полагается на правильное
использование таймеров. В обоих случаях заостряется внимание на требуемом
свойстве безопасности, а именно на том, что приемник получит только
правильные данные.

Первый протокол (Раздел 3.1) разработан для обмена данными
между двумя станциями, которые имеют прямое физическое соединение (типа
телефонной линии), и, следовательно, принадлежит канальному уровню модели OSI.
Второй протокол (Раздел 3.2) разработан для использования двумя станциями,
которые  связываются через промежуточную сеть (возможно содержащую другие
станции и соединяющую станции через различные пути), и этот протокол
следовательно принадлежит к транспортному уровню OSI модели. Это различие
отражается на  функциональных возможностях, требуемых от протоколов, следующим
образом.

(1) Рассматриваемые
ошибки. Для двух протоколов будут рассматриваться различные классы ошибок передачи.
Сообщения не могут пересекаться при физическом соединении, и они не могут быть
продублированы; таким образом, в разделе 3.1 рассматривается только потеря
сообщений (об искажении сообщений см. ниже). В сети сообщения могут
передаваться различными путями, и, следовательно, пересекаться; также, из-за
отказов промежуточных станций сообщения могут быть продублированы или потеряны.
В Разделе 3.2 будут рассматриваться потеря, дублирование и переупорядочение сообщений.

(2) Управление
соединением. Далее, управление соединением не будет рассматриваться для
первого протокола, но будет для второго. Предполагается, что физическое
соединение  функционирует непрерывно в течение очень длительного времени, а не
открывается и закрывается неоднократно. Для соединений с удаленными станциями
это не так. Такое соединение может быть необходимо временно для обмена некоторыми
данными, но обычно слишком дорого поддерживать соединение с каждой удаленной
станцией неопределенно долго. Следовательно, для второго протокола будет
требоваться способность открывать и закрывать соединение.

При рассмотрении первого протокола показывается, что не
только механизмы, основанные на таймерах, могут обеспечить требуемые свойства
безопасности протоколов передачи данных. Раздел 3.1 служит первым большим
примером доказательства свойств безопасности с помощью инструментальных
средств, описанных в Разделе 2.2. Многие полагают [Wat81], что правильное
использование таймеров и ограничение на время, в течение которого сообщение
может передаваться ,  необходимы для безопасного управления соединением. Таким
образом, для того, чтобы доказать безопасность протоколов, нужно принимать во
внимание роль таймеров в управлении соединением. Раздел 3.2 показывается, как модель
распределенных систем (Определение 2.6) может быть расширена до процессов,
использующих таймеры, и дает пример этого расширения.

Искажение сообщений. Естественно принять во внимание
возможность того, что сообщения могут быть искажены в течение передачи.
Содержание сообщения, переданного через физическое соединение, может быть
повреждено из-за атмосферных шумов, плохо функционирующих модулей памяти, и
т.д. Однако можно предположить, что искажение сообщения может быть обнаружено
процессом-получателем, например, посредством контроля четности или более общих
механизмов контрольной суммы ( [Tan88, Глава 41). Получение искаженного
сообщения затем обрабатывается так, как будто не было получено никакого сообщения,
и таким образом, искажение сообщения фактически вызывает его потерю. По этой
причине искажение не обрабатывается явно; вместо этого всегда рассматривается
возможность потери сообщения.

3.1
Сбалансированный протокол скользящего окна

В этом разделе изучается симметричный протокол, который
обеспечивает надежный обмен информацией в обоих направлениях. Протокол взят из
[Sch91, Глава 2]. Поскольку он используется для обмена информацией между станциями,
которые непосредственно соединены через линию, можно предположить, что каналы
имеют дисциплину fifo. Это предположение не используется, однако, до Подраздела
3.1.3, где показано, что числа последовательности, используемые протоколом
могут быть ограничены. Протокол представлен в Подразделе 3.1.1, а в Подразделе
3.1.2 доказывается его правильность.

Два процесса связи обозначаются как p и q.
Предположения, требования и протокол абсолютно симметричны. Вход p
состоит из информации, которую он должен послать q, и моделируется
неограниченным массивом слов inp. Выход  p состоит из
информации, которую он получает от q, и также моделируется неограниченным
массивом слов, outp. Предполагается, что p имеет
случайный доступ по чтению к  inp  и случайный доступ по
записи к outp. Первоначально значение outp[i]
не определено и представлено как udef для всех i. Вход и выход
процесса  q моделируется массивами inq и outq
соответственно. Эти массивы нумеруются натуральными числами, т.е. они
начинаются со слова с номером 0. В подразделе 3.1.3 будет показано, что
произвольный доступ может быть ограничен доступом к "окну" конечной
длины, передвигающемуся вдоль массива. Поэтому протокол называется протоколом
«скользящего окна».

Процесс p содержит переменную sp,
показывающую наименьшее нумерованное слово, которое p все еще ожидает от
q. Таким образом, в любой момент времени, p уже записал слова от outp[0]
до outp[sp – 1]. Значение sp  никогда не
уменьшается. Аналогично q содержит переменную sq.
Теперь могут быть установлены требуемые свойства протокола. Свойство
безопасности говорит о том, что каждый процесс передает только корректные
данные; свойство живости говорит о том, что все данные когда-либо будут
доставлены.

(1) Свойство
безопасности. В каждой достижимой конфигурации протокола

outp[0..sp
— 1] = inq[0..Sp — 1] и outq[0..sq
— 1] = inp [0…sq — 1].

(2) Окончательная
доставка. Для каждого целого k ³
0, конфигурации с sp ³
k и
sq ³ k
когда-либо достигаются.

3.1.1 Представление
протокола

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

Сообщения, которыми обмениваются процессы, называют пакетами,
и они имеют форму
< pack, w, i >, где w – слово данных, а i
– натуральное число (называемое порядковым номером пакета). Этот пакет,
посылаемый процессом p (к q), передает слово = inp[i]
для q, но также, как было отмечено, подтверждает получение некоторого
количества пакетов от q. Процесс p может быть «впереди» q
не более, чем на lp пакетов, если мы потребуем, что пакет
данных < pack, w, i >, посланный p, подтверждает
получение слов с номерами 0.. i— lp от q. (q
посылает аналогичные пакеты.) Константы lp и lq
неотрицательны и известны обоим процессам p и q. Использование
пакета данных в качестве подтверждения имеет два последствия для протокола:

(1)  Процесс
p может послать слово inp[i] (в виде пакета <
pack, inp[i], i >) только после
того, как запишет все слова от outp[0] до outp[i
— lp], т. е. , если i < sp + lp.

(2)  Когда
p принимает < pack, w,i>, повторная передача
слов с inp[0] до inp[i — lq] уже
не нужна.

Объяснение псевдокода. После выбора модели нетрудно разработать
код протокола; см. Алгоритм 3.1. Для процесса p введена переменная ap
(и aq для q), в которой хранится самое
первое слово, для которого p (или q, соответственно) еще не получил
подтверждение..

В Алгоритме 3.1 действие Sp –
посылка i-го слова процессом p, действие Rp
– принятие слова процессом  p, и действие Lp –
потеря пакета с местом назначения p. Процесс p может послать
любое слово, индекс которого попадает в указанные ранее границы. Когда
сообщение принято, в первую очередь делается проверка – было ли идентичное
сообщение принято ранее (на случай повторной передачи). Если нет, слово, содержащееся
в нем, записывается в выход, и ap и sp
корректируются. Также вводятся действия Sq, Rq
и Lq , где p и q поменяны ролями.

 

var sp, ap : integer                  init
0, 0 ;

    inp    :
array of word           (* Посылаемые данные *) ;

    outp   :
array of word            init udef, udef, …’,

Sp: {ap
£ i < Sp+lp}

    begin send < pack,inp[i],i>
to q end

Rp: { < pack, w, i > ÎQp
}

    begin receive <pack, w, i> ;

          if outp[i] = udef then

             begin outp[i] := w ;

                   ap
:= max(ap,i-lp+1) ;

                   Sp
:= min{j|outp[j]= udef}

             end

           (* else
игнорируем, пакет передавался повторно *)

    end

Lp: {<pack,w,i>ÎQp}

begin Qp := Qp\ {<pack,w,i>}
end

Алгоритм 3.1 Протокол скользящего окна (для p).

 

 

Инвариант протокола. Подсистема связи представляется
двумя очередями, Qp для пакетов с адресатом p и Qq,
для пакетов с адресатом q. Заметим, что перевычисление sp
в Rp никогда не дает значение меньше предыдущего,
поэтому sp никогда не уменьшается. Чтобы показать, что этот
алгоритм удовлетворяет данным ранее требованиям, сначала покажем, что
утверждение P – инвариант. (В этом и других утверждениях i – натуральное
число.)

P º      "i < sp : outp[i]¹ udef                                     (0p)

/\ "i
< sq, : outq[i] ¹ udef                                             (0q)

/\ < pack, w, i > Î Qp  Þ  w = inq[i]
/\ (i < sq + lq)   (lp)

/\ < pack, w, i > Î Qq  Þ  w = inp[i]
/\ (i < sp + lp)   (lq)

/\ outp[i]¹ udef  Þ
outp[i] = inq[i] /\ (ap
> i— lq)     (2p)

/\ outq[i]¹ udef  Þ
outq[i] = inp[i] /\ (aq
> i— lp)     (2q)

/\ ap £
sq,                                                          (3p)

/\ aq £ sp                                           
                           (3q)

Лемма 3.1 P – инвариант Алгоритма 3.1.

Доказательство. В любой начальной конфигурации Qp
и Qq – пустые, для всех i, outp[i] и outq[i]
равны udef, и ap,ap, sp и sq равны
нулю 0; из этого следует, что P=true. Перемещения протокола рассмотрим с точки
зрения сохранения значения P. Во-первых, заметим, что значения inp и
inq, никогда не меняются.

Sp: 
Чтобы показать, что Sp сохраняет (0p), заметим, что Sp
не увеличивает sp и не делает ни один из outp[i] равным
udef.

Чтобы показать, что Sp
сохраняет (0q), заметим, что Sp не увеличивает sq,
и не       делает ни один из outq[i] равным udef.

Чтобы показать, что Sp
сохраняет (1p), заметим, что Sp не добавляет пакеты в Qp
и не уменьшает sp.

Чтобы показать, что Sp
сохраняет (lq), заметим Sp добавляет < pack, w, i
> в Qp с w = inp[i] и i < sp + lp,
и не изменяет значение sp.

Чтобы показать, что Sp сохраняет (2p) и (2q),
заметим, что Sp
не изменяет значения outp,
outq, ap, или aq.

Чтобы показать, что Sp сохраняет (3p) и (3q),
заметим, что Sp
не меняет значения  ap ,
ap , sq , или sp.

Rp:  Чтобы показать, что Rp сохраняет (0p), заметим, что Rp не делает ни одно outp[i] равным udef, и если он
перевычисляет sp, то
оно впоследствии также удовлетворяет (0p).

Чтобы показать, что Rp сохраняет (0q), заметим, что Rp не меняет outq или sq.

Чтобы показать, что Rp сохраняет (lp), заметим, что Rp не добавляет пакеты в Qp и не уменьшает sq.

Чтобы показать, что Rp сохраняет (lq), заметим, что Rp не добавляет пакеты в Qq и не уменьшает sp.

Чтобы показать, что Rp сохраняет (2p), заметим, что
Rp изменяет
значение outp[i] на w
при принятии < pack, w,i>. Т.к. Qp содержала этот пакет до того, как выполнился Rp, из (1p) следует, что w = inp[i]. Присваивание ap:= max (ap, i— lq+1) гарантирует, что ap > i— lq сохраняется после выполнения.
Чтобы показать, что Rp
сохраняет (2q), заметим, что Rp
не меняет значения outq
или aq.

Чтобы показать, что Rp сохраняет (3p), заметим, что
когда Rp
присваивает
ap:= max(ap, i— lq+1) (при принятии  <pack,
w,i>), из (lp) следует, что i < sq+lq,
следовательно ap £ sq 
сохраняется после присваивания. Rp
не меняет sq. Чтобы
показать, что Rp
сохраняет (3q), заметим, что sp
может быть увеличен только при выполнении Rp.

Lp   : Чтобы показать, что Lp сохраняет (0p), (0q), (2p),
(2q), (3p), и (3q), достаточно заметить, что Lp не меняет состояния процессов.
(lp) и (lq) сохраняются потому, что Lp
только удаляет пакеты (а не порождает или искажает их).

Процессы  Sq, Rq, и Lq сохраняют  P , что следует из
симметрии.                      ð3.1.2
Доказательство правильности протокола

 

Сейчас будет продемонстрировано, что Алгоритм 3.1
гарантирует безопасную и окончательную доставку. Безопасность следует из
инварианта, как показано в Теореме 3.2, а живость продемонстрировать труднее.

 

Теорема 3.2 Алгоритм 3.1 удовлетворяет требованию
безопасной доставки.

Доказательство. Из (0p) и (2p) следует, что outp[0..sp —1] =inq[0..sp—1], а из (0q) и (2q) следует 
outp[0..Sq -1] = inp[0..Sq -1].ð

Чтобы доказать живость протокола, необходимо сделать
справедливых предположений и предположение относительно lp и lq. Без этих предположений
протокол не удовлетворяет свойству живости, что может быть показано следующим
образом. Неотрицательные константы lp и lq еще не определены; если их выбрать равными
нулю, начальная конфигурация протокола окажется тупиковой. Поэтому предполагается,
что lp + lq > 0.

Конфигурация протокола может быть обозначена g = (cp, cq, Qp,
Qq), где cp и cq – состояния  p и q.
Пусть g будет конфигурацией, в которой
применим Sp
(для некоторого i). Пусть

   d =
Sp(g) = (cp, cq, Qp,
(Qq È {m})),
и отметим, что действие Lq
применимо в d. Если  Lq  удаляет m, Lq(d) = g. Отношение
Lq(Sp(g)) = g
äàåò íà÷àëî
íåîãðàíè÷åííûì
âû÷èñëåíèÿì,
â êîòîðûõ íè sp , ни sq не уменьшаются.

Протокол удовлетворяет требованию «окончательной доставки»,
если удовлетворяются два следующих справедливых предположения.

Fl. Если посылка пакета возможна в течение бесконечно
долгого временно, пакет посылается бесконечно часто.

F2. Если один и тот же пакет посылается бесконечно часто, то
он принимается бесконечно часто.

Предположение Fl гарантирует, что пакет посылается снова и
снова, если не получено подтверждение; F2 исключает вычисления, подобные
описанному выше, когда повторная передача никогда не принимается.

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

 

Ëåììà 3.3 Из P
следует sp— lq £ ap £ sq £ aq+ lp £ sp + lp.

 

Äîêàçàòåëüñòâî.
Из (0p) и (2p) следует sp—
lq£ ap, из (3p) следует  ap£ sp
. Из (0q) и (2q)       следует sp
£ ap
+ lp . Из
(3q) следует ap
+ lp £ sp + lp .ð

 

Òåîðåìà 3.4 
Àëãîðèòì 3.1 удовлетворяет
требованию окончательной доставки.

 

Äîêàçàòåëüñòâî.
Сначала будет продемонстрировано, что в протоколе невозможны тупики. Из инварианта
следует, что один из двух процессов может послать пакет, содержащий слово с
номером, меньшим, чем ожидается другим процессом.

 

Утверждение 3.5 Из P следует, что посылка <
pack, in[sq],
sq>
процессом p или посылка
< pack, inq[sp], sp
) процессом  q возможна.

 

Äîêàçàòåëüñòâî.
Т.к. lp + lq > 0, хотя бы одно из неравенств
Ëåììы 3.3 строгое, т.е.,

sq <
sp + lp   \/   sp
< sq+lq.

Из P также следует ap £ sq (3p) и aq £ sp (3q), а также следует, что

(ap £ sq<sp+lp) \/ (aq
£ sp<sq+lq)

это значит, что Sp
применим с i = sq или Sq применим с i = sp.       ð

Теперь мы можем показать, что в каждом из вычислений sp и sq
увеличиваются бесконечно часто. Согласно Утверждению 3.5 протокол не имеет
терминальных конфигураций, следовательно каждое вычисление неограниченно. Пусть
C – вычисление, в котором sp
и sq увеличиваются
ограниченное число раз, и пусть sp
and sq –
максимальные значения, которые эти переменные принимают в C. Согласно
утверждению, посылка <pack, inp[sq], sq> процессом p или
посылка <pack, in q[sp], sp
> процессом q применима всегда после того, как sp,
sq, ap и aq достигли своих
окончательных значений. Таким образом, согласно Fl, один из этих пакетов
посылается бесконечно часто, и согласно F2, он принимается бесконечно часто.
Но, т.к. принятие пакета с порядковым номером sp процессом p приводит к увеличению sp (и наоборот для q), это противоречит
допущению, что ни sp, ни sq  не
увеличиваются более. Таким образом
Òåîðåìà 3.4
доказана.                                                              ð

Мы завершаем этот подраздел кратким обсуждением
предположений Fl и F2.
F2-ìèíèìàëüíîå
требование, которому должен удовлетворять канал, соединяющий p и q,
для того, чтобы он мог передавать данные. Очевидно, если некоторое слово inp[i] никогда не проходит через канал, то
невозможно достичь окончательной доставки слова. Предположение Fl обычно
реализуется в протоколе с помощью условия превышения времени: если ap не увеличилось в течение определенного
промежутка времени, inp[ap] передается опять. Как уже было отмечено
во введении в эту главу, для этого протокола безопасная доставка может быть
доказана без принятия во внимания проблем времени (тайминга).

3.1.3
Обсуждение протокола

Ограничение памяти в процессах.
Àëãîðèòì 3.1 не годится для
реализации в компьютерной сети, т.к. в каждом процессе хранится бесконечное
количество информации (массивы in и out) и т.к. он использует неограниченные
порядковые номера. Сейчас будет показано, что достаточно хранить только
ограниченное число слов в каждый момент времени. Пусть L = lp + lq.

Ëåììà 3.6 Из P
следует, что отправление < pack, w,i> процессом p применимо
только для i < ap+L.

 

Äîêàçàòåëüñòâî.
Сторож Sp требует i <
sp+lp, значит согласно Ëåììе 3.3 i
< ap+L.   ð                                                     

 

Ëåììà 3.7 Из P следует,
что если outp[i]¹ udef, то i < sp + L.

 

Äîêàçàòåëüñòâî.
Из (2p), ap > i—
lq, значит i < ap + lq,
и i < sp + L
(из Ëåììы 3.3). ð 

Ðèñóíîê
3.2 Скользящие окна протокола.

                                  

Последствия этих двух лемм отображены на
Ðèñóíêе 3.2. Процессу p необходимо
хранить только слова inp[ap..sp
+ lp — 1] потому, что это
слова, которые p может послать. Назовем их как  посылаемое окно  p
(представлено как S на Ðèñóíêе 3.2).
Каждый раз, когда ap
увеличивается, p отбрасывает слова, которые больше не попадают в
посылаемое окно (они представлены как A на
Ðèñóíêе 3.2). Каждый раз, когда sp увеличивается, p считывает
следующее слово из посылаемого окна от источника, который производит слова.
Согласно Ëåììе 3.6, посылаемое окно процесса p
содержит не более L слов.

Подобным же образом можно ограничить память для хранения
процессом p массива outp.
Т.к. outp[i] не меняется для
i < sp, можно
предположить, что p выводит эти слова окончательно и более не хранит их
(они представлены как W на Ðèñóíêе 3.2).
Т.к. outp[i] = udef
для всех i ³ sp + L, эти значения outp[i] также не нужно хранить. Подмассив outp[sp..sp +L—1] назовем принимаемое окно p.
Принимаемое окно представлено на Ðèñóíêе
3.2 как u для неозначенных слов и R для слов, которые были приняты. Только
слова, которые попадают в это окно, хранятся процессом. Леммы 3.6 и 3.7
показывают, что не более 2L слов хранятся процессом в любой момент
времени.

Ограничение чисел последовательности. В заключение
будет показано, что числа последовательности могут быть ограничены, если
используются fifo-каналы. При использовании fifo предположения можно показать,
что номер порядковый номер пакета, который получен процессом p  всегда
внутри 2L-окрестности sp. Обратите внимание, что fifo
предположение используется первый раз.

Ëåììà 3.8 Утверждение
P’, определяемое как

P’ º
P

/\ <pack, w, i> is behind <pack,
w’, i’> in Qp Þ i > i’ – L     (4p)

/\ <pack, w, i> is behind <pack,
w’, i’> in Qq Þ i > i’ – L     (4q)

/\ <pack,w,i> ÎQp Þ i³ ap – lp                                               (5p)

/\ <pack,w,i> ÎQq Þ i³ aq – lq                                               (5q)

является инвариантом 
Àëãîðèòìа 3.1.

 

Äîêàçàòåëüñòâî.
Т.к. уже было показано, что P – инвариант, мы можем ограничиться
доказательством того, что (4p), (4q), (5p) и (5q) выполняются изначально и
сохраняются при любом перемещении. Заметим, что в начальном состоянии очереди
пусты, следовательно (4p), (4q), (5p) и (5q) очевидно выполняются. Сейчас
покажем, что перемещения сохраняют истинность этих утверждений.

Sp: Чтобы показать, что Sp
сохраняет (4p) и (5p), заметим, что Sp не добавляет пакетов в
Qp и не меняет ap.

Чтобы показать, что Sp
сохраняет (5q), заметим, что если Sp добавляет пакет <pack,
w, i> в Qq, то i ³ ap,
откуда следует, что i³
 aq – lq (из Ëåììы 3.3).

Чтобы показать, что Sp
сохраняет (4q), заметим, что если < pack, w’, i’> в Qq,
тогда из (lq)
i’ < sp + lp, следовательно, если Sp
добавляет пакет < pack, w, i> с i ³ ap, то из Леммы 3.3 следует  i’ < ap+L £
i+L.

Rp: Чтобы показать, что Rp
сохраняет (4p) and (4q), заметим, что Rp не добавляет пакеты в Qp или Qq.

 Чтобы показать, что Rp
сохраняет (5p), заметим, что когда ap
увеличивается (при принятии <pack, w’, i’>) до   i’
– lq +1, тогда для любого из
оставшихся пакетов <pack, w, i> в Qp мы имеем i > i’ – L (из 4р).
Значит неравенство i ³ ap – lp
сохраняется после увеличения ap.

Чтобы показать, что Rp
сохраняет (5q), заметим, что  Rp
не меняет Qq  и aq.

Lp: Действие Lp не добавляет пакетов в Qp или Qq, и не меняет значения ap или aq;
значит оно сохраняет (4p), (4q), (5p) и (5q).

Из симметрии протокола следует, что Sq, Rq
и Lq тоже сохраняет P’.
ð

                                                      

Ëåììà 3.9 Из P’
следует, что

<pack, w,i>Π Qp Þ sp -L£ i<
sp +L

и

 <pack, w,i>Π Qq Þ sq -L£
i< sq +L.

 

Äîêàçàòåëüñòâî.
Пусть <pack, w,i> Î
Qp. Из (lp), i < sq + lq,
и из Ëåììы 3.3 i < sp + L. Из (5p), i ³ ap— lp, и
из Ëåììы 3.3 i ³ sp— L.
Утверждение относительно пакетов в Qq
доказывается так же. ð

Согласно Ëåììе достаточно посылать
пакеты с порядковыми номерами modulo k, где
k ³ 2L.
В самом деле, имея sp и i
mod k,  p может вычислить i.

 

Выбор параметров. Значения констант lp и lq
сильно влияют на эффективность протокола. Их влияние на пропускную
способность протокола анализируется в [Sch91, Chapter 2]. Оптимальные значения
зависят от числа системно зависимых параметров, таких как

время связи, т.е., время между двумя
последовательными операциями процесса,

время задержки на обмен, т.е., среднее время на
передачу пакета от p к q и получение ответа от q к p,

вероятность ошибки, вероятность того, что конкретный
пакет потерян.

Протокол, чередующий бит. Интересный случай протокола
скользящего окна получается, когда L = 1, ò.å., lp = 1 и lq= 0 (или наоборот). Переменные ap и aq,
инициализируется значениями -lp
и -lq, а не 0. Можно показать,
что ap + lq = sp
и aq + lp = sq
всегда выполняется, значит только одно  ap
и sp (и aq и sq)
нужно хранить в протоколе. Хорошо известный протокол, чередующий бит [Lyn68]
получается, если использование таймеров дополнительно ограничивается, чтобы гарантировать,
что станции посылают сообщения в ответ.

3.2 Протокол,
основанный на таймере

Теперь мы изучим роль таймеров в проектировании и проверке
протоколов связи,  анализируя упрощенную форму Dt-протокола
Флэтчера и Уотсона (Fletcher и Watson) для сквозной передачи сообщений. Этот протокол
был предложен в [FW78], но (несколько упрощенный) подход этого раздела взят из
[Tel91b, Раздел 3.2]. Этот протокол обеспечивает не только механизм для
передачи данных (как сбалансированный протокол скользящего окна Раздела 3.1),
но также открытие и закрытие соединений. Он устойчив к потерям, дублированию и
переупорядочению сообщений.

Информация о состоянии (передачи данных) протокола хранится
в структуре данных, называемой запись соединения. (В Подразделе 3.2.1
будет показано, какая информация хранится в записи соединения). Запись
соединения может быть создана и удалена для открытия и открытия соединения.
Òàêèì
îáðàçîì,
ãîâîðÿò, ÷òî
ñîåäèíåíèå
îòêðûòî (на одной из станций), если
существует запись соединения.

Чтобы сконцентрироваться на релевантных аспектах протокола (а
именно, на механизме управления соединением и роли таймеров в этом механизме),
будем рассматривать упрощенную версию протокола. Более практические и эффективные
расширения протокола могут быть найдены [FW78] и [Tel91b, Раздел 3.2]. В протоколе,
описанном здесь, сделаны следующие упрощения.

One direction. Подразумевается, что данные передаются
в одном направлении, скажем от p к q. Иногда будем называть p отправителем,
а q – адресатом (приемником). Однако, следует отметить, что
протокол использует сообщения подтверждения, которые посылаются в обратном
направлении, т.е. от q к p.

Обычно данные нужно передавать в двух направлениях. Чтобы
предусмотреть подобную ситуацию, дополнительно выполняется второй протокол, в
котором p и q поменяны ролями. Тогда можно ввести комбинированные
data/ack (данные/подтверждения) сообщения, содержащие как данные (с
соответствующим порядковым номером), так
и информацию, содержащуюся в пакете подтверждения протокола, основанного на
таймере.

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

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

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

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

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

Глобальное время. Глобальная мера времени
простирается над всеми процессами системы, то есть каждое событие происходит в
некоторое время. Предполагается, что каждое событие имеет продолжительность 0,
и время, в которое происходит событие,  не доступно процессам.

Ограниченное время жизни пакета. Время жизни пакета
ограничено константой m (максимальное
время жизни пакета). Òàêèì
îáðàçîì, если пакет посылается во
время s и принимается во время t, то

s < t < s + m.

Если пакет дублируется в канале, каждая копия должна быть
принята в течение промежутка времени m
после отправления оригинала (или стать потерянной).

Таймеры. Процессы не могут наблюдать абсолютное время
своих действий, но они имеют доступ к таймерам. Таймер – действительная
переменная процесса, чье значение непрерывно уменьшается со временем (если
только ей явно не присваивают значение). Точнее, если Xt – таймер, мы
обозначаем его значение в момент времени t как Xt(t) и если Xt
между t1 and t2 не присвоено иное значение,
то

Xt(t1)-Xt(t2)=t2-t1.

Заметим, что эти таймеры работают так: в течение времени d они уменьшаются точно на d. В Подразделе 3.2.3 мы обсудим случай,
когда таймеры страдают отклонением.

Входные слова для отправителя моделируются, как в Разделе
3.1, неограниченным массивом inp. Снова этот массив не
полностью хранится в p; p в каждый момент времени имеет доступ
только к его части. Часть inp, к которой p имеет
доступ расширяется (в сторону увеличения индексов),
êîãäà p получает следующее слово от
процесса, который их генерирует. Эту операцию будем называть как принятие слова
отправителем.

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

Спецификация протокола, однако, слабее, и причина в том, что
протокол позволяется обрабатывать каждое слово inp только в
течение ограниченного интервала времени. Не каждый протокол может
гарантировать, что слово принимается за ограниченное время потому, что
возможно, что все пакеты в это время потеряются. Следовательно, спецификация
протокола учитывает возможность сообщенной потери, когда протокол
отправителя генерирует отчет об ошибке, указывающий, что слово возможно
потеряно. (Если после этого протокол более высокого уровня предлагает это слово
p снова, то возможно дублирование; но мы не будем касаться этой проблемы
здесь.) Свойства протокола, который будет доказан в Подразделе 3.2.2:

Нет потерь. Каждое слово inp доставляется процессом q или
посылается отчет процессом p ("возможно потеряно" ) в течение
ограниченного времени после принятия слова процессом p.

Упорядочение. Слова, доставляемые q
принимаются в строго возрастающем порядке (так же, как они появляются в inp).

3.2.1
Представление Протокола

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

Когда отправитель открывает
новое соединение, он начинает нумеровать принятые слова с 0. Количество уже
принятых слов в данном соединении обозначается High, и количество слов,
для которых уже было получено подтверждение обозначается через Low. Это
подразумевает (аналогично протоколу Раздела 3.1), что отправитель может
передавать пакеты с порядковыми номерами в диапазоне от Low до High —1,
но есть здесь и своя особенность. Отправитель может посылать слово только в
течение промежутка времени длиной U, начиная с того момента, когда
отправитель принял слово. Для этого с каждым словом inp[i] ассоциируется
таймер Ut[i], он устанавливается в U в момент принятия, и должен
быть положительным для передаваемого слова.
Òàêèì
îáðàçîì, посылаемое окно p
состоит из тех слов с индексами Low …High – 1, для которых ассоциированный
с ними таймер положителен.

Сетевые константы:

m    : real
;       (* Максимальное время жизни пакета *)

Константы протокола:

U    : real ;       (* Длина интервала отправки *)

R    : real ;       (* Значение тийм-аута приемника: R³ U+m *)

S     : real ;       (* Значение тайм-аута
отправителя: S ³
R + 2m *)

Запись соединения отправителя:

Low   : integer ;    (* Подтвержденные слова текущего
соединения *)

High  : integer ;    (* Принятые слова
текущего соединения *)

St       : timer ;      (* Таймер соединения *)

Запись соединения приемника:

Exp  : integer ;             (* Ожидаемый порядковый
номер *)

Rt     : timer ;               (* Таймер соединения
*)

Подсистема связи:

Mq    : channel ;           (* Пакеты данных для q
*)

Mp   : channel ;           (* Пакеты подтверждения
для p *)

Вспомогательные переменные:

B    : integer init 0 ;                 (*
Слова в предыдущем соединении *)

cr    : boolean init false ;         (*
Существование соединения для приемника *)

cs    : boolean init false ;         (*Существование
соединения для отправителя *)

Ðèñóíîê
3.3 Переменные протокола, основанного на таймере.

Протокол посылает пакеты
данных, состоящие из: бита (бит начала-последовательности; его значение
будет обсуждаться позже), порядкового номера и слова. Для анализа протокола
каждый пакет данных содержит четвертое поле, называемое оставшееся время
жизни пакета. Оно показывает максимальное время, в течение которого пакет
еще может находиться в канале до того, как он должен быть принят или стать потерянным
согласно предположению об ограниченном времени жизни. В момент отправления
оставшееся время жизни пакета всегда равно m. Пакеты подтверждения протокола состоят только
из порядкового номера, ожидаемого процессом q, но опять для целей
анализа каждое подтверждение содержит оставшееся время жизни пакета.

Ap: (* Принятие следующего слова *)

begin if not cs then

begin (* Сначала соединение открывается *)

create (St, High, Low) ;
(* cs := true *)

Low := High := 0 ; St := S

end;

Ut[B + High] := U, High :=
High + 1

end

 

Sp: (* Отправление i-го слова текущего соединения
*)

{ cs /\ Low £ i < High /\ Ut[B + i] >
0}

begin      

send <data, (i = Low),i,
inp[B + i],m > ;

St:=S

end

 

Rp:          (* Принятие подтверждения *)

{ cs /\ <ack,
i, r >Π Mp }

begin receive <ack, i, r > ; Low := max (Low, i) end

 

Ep:         
(* Генерация сообщения об ошибке для возможно потерянного слова *)

{cs /\ Ut[B + Low] £ -2m -R}

begin error [B + Low] := true ; Low
:= Low + 1 end

 

Cp:         
(* Закрытие соединения *)

{cs /\ St < 0 /\ Low
= High }

begin B := B + High , delete (St, High, Low)
end

(* cs := false *)

Àëãîðèòì 3.4 Протокол отправителя.

Закрытие соединения
контролируется таймерами, таймером St для отправителя и таймером Rt
для приемника. Ограниченный интервал посылки каждого слова и ограниченное время
жизни пакета приводят к тому, что каждое слово может быть найдено в каналах
только лишь в течение интервала времени длиной m + U, начиная с момента принятия слова. Это позволяет
приемнику отбрасывать информацию о конкретном слове через m + U  единиц времени после
принятия слова; после этого не могут появиться дубликаты, следовательно не
возможна повторная доставка. Таймер Rt устанавливается в R каждый
раз, когда слово доставляется, константа R выбирается так, чтобы
удовлетворять неравенству R ³
U + m. Если следующее слово
принимается в течение R единиц времени, то таймер Rt обновляется,
иначе соединение закрывается. Значение таймера отправители выбирается так,
чтобы невозможно было принять подтверждение при закрытом соединении; для этого,
соединение поддерживается в течение по крайней мере S единиц времени
после отправления пакета, где S – константа, выбираемая так, чтобы
удовлетворять S ³
R+2m. Таймер St устанавливается
в S каждый раз, когда посылается пакет, и соединение может быть закрыто
только если St < 0. Если к этому времени еще остались незавершенные
слова (ò.å. слова, для которых не было получено подтверждение),
эти слова объявляются потерянными до закрытия соединения.

 

Rq:          (* Принимаем пакет данных *)

{ <data, s, i,w,r > Î Mq }

begin receive <data, s, i,w,r > ;

if cr then

   if i = Exp then

begin Rt := R ; Exp := i + 1 ; deliver w
end

else if s = true then

    begin create (Rt, Exp) ; (* cr := true *)

Rt := R ; Exp := i +1 ; deliver w

    end

end

 

Sq:           (*
Посылаем подтверждение *)

{cr}

                begin
send <ack, Exp, m > end

(* Закрытие соединения по
истечении времени Rt, см. В действии Time *)

 

Àëãîðèòì
3.5 Протокол приемника

Бит начало-последовательности используется приемником, если
пакет получен при закрытом соединении, чтобы решить, может ли быть открыто
соединение (и доставлено слово в пакете ). Отправитель устанавливает бит в
true, если все предыдущие слова были подтверждены или объявлены (как возможно
потерянные). Когда q получает пакет при уже открытом соединении, 
содержащееся слово доставляется тогда и только тогда, когда порядковый номер
пакета равен ожидаемому порядковому номеру (хранится в Exp).

Остается обсудить значение
переменной B в протоколе отправителя. Это вспомогательная переменная, введенная
только с целью доказательства правильности протокола. Отправитель нумерует
слова в каждом соединении, начиная с 0, но, чтобы различать слова в различных
соединениях, все слова индексируются последовательно по возрастанию для анализа
протокола. Таким образом, там, где отправитель индексирует слово как i,
"абсолютный" номер указанного слова  B + i, где B – общее
количество пакетов, принятых p в предыдущих соединениях. Соответствие
между "внутренними" и "абсолютными" номерами слов показывается
на Рисунке 3.7. В реализации протокола B не хранится, и отправитель
"забывает" все слова inp [0 .. B-1].

Loss:  { m Î M }   
(* M – либо  Mp, либо Mq *)

begin remove m from M end

Dupl: { m ÎM }    (*M – либо  Mp, либо Mq
*)

begin insert m in M end

Time:  (* d > 0 *)

begin forall i do Ut[i] := Ut[i] -d ,

St := St -d  ; Rt
:= Rt – d ;

if Rt £ 0 then delete (Rt, Exp) ;  (* cr := false *)

forall <.., r> Î Mp, Mq do

begin r := r— d
;

                         if
r £ 0 then remove packet

               end

end

Àëãîðèòì
3.6 Дополнительные переходы Протокола.

Подсистема связи
представляется двумя мультимножествами, Mp для пакетов с
адресатом p и Mq для пакетов с адресатом q.
Протокол отправителя – Алгоритм 3.4, протокол приемника – Алгоритм 3.5. Имеются
дополнительные переходы системы, представленные Алгоритмом 3.6, которые не
соответствуют шагам в протоколе процессов. Эти переходы представляют собой
отказы канала и изменение времени. В переходах Loss и Dupl M
означает или Mp, или Mq. Действие Time уменьшает
все таймеры в системе на величину d,
это случается между двумя дискретными событиями, которые отличаются на d единиц времени. Когда таймер приемника
достигает значения 0, соединение закрывается.

 

Ðèñóíîê
3.7 Порядковые номера протокола.

 

3.2.2 Доказательство корректности протокола

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

P0 º       
cs Þ St £ S                                        
                      (1)

cr Þ 0 < Rt£
R                                                           (2)

"i
< B+ High : Ut[i] £
U                                           (3)

"<…
r>Î Mp, Mq : 0 <r £ m                          (4)

 < data, s, i,w, r>Î
Mq Þ cs ÙSt³ r
+m+R               (5)

 crÞ
cs /\  St ³ Rt + m                                                 (6)

<ack,i, r> ÎMp
Þ
cs /\ St>r                                     (7)

<data, s, i, w, r >ÎMq Þ 
(w = inp[B + i] /\ i < High) (8)

Объяснение к (3): значение High предполагается равным
нулю во всех конфигурациях, в которых со стороны приемника нет соединения.

Ëåììà 3.10 P0
– инвариант протокола, основанного на таймере.

Äîêàçàòåëüñòâî.
Первоначально не соединения, нет пакетов, и B = 0, из чего следует, что P0
– true.

Ap:
(1) сохраняется, т.к. St всегда присваивается значения S (St =
S). (3) сохраняется, т.к. перед увеличением High, Ut[B + High] присваивается
значение U. (5), (6) и (7) сохраняются, т.к. St может только
увеличиваться. (8) сохраняется, т.к. High может только увеличиваться.

Sp:
(1) сохраняется, т.к. St всегда присваивается значения S. (4)
сохраняется, т.к. каждый пакет посылается с оставшимся временем жизни равным m. (5) сохраняется, т.к. пакет <..,  m> посылается и St
устанавливается в S, и S = R + 2m.
(6) и (7) сохраняется, т.к. St может только увеличиться в этом действии.
(8) сохраняется, т.к. новый пакет удовлетворяет w = inp[B + i] и i < High.

Rp:
Действие Rp не меняет
никаких переменных из P0, и удаление пакета сохраняет (4) и
(7).

Ep:
Действие Ep не меняет
никаких переменных из P0.

Cp:
Действие Cp делает равным false
заключения (5), (6) и (7), но ((2), (5), (6) и (7)) применимы только когда их
посылки ложны. Cp также меняет значение B, но, т.к.
пакетов для передачи нет, (по (5) и (7)), (8) сохраняется.

Rq:
(2) сохраняется, т.к. Rt всегда присваивается значение R (если присваивается).
(6) сохраняется, т.к. Rt устанавливается только в R только при
принятии пакета <data, s,i,w,r>,
è из (4) и (5) следует  cs Ù
St ³ R + m когда это происходит.

Sq:
(4) сохраняется, т.к. каждый пакет посылается с оставшимся временем жизни,
равным m. (7) сохраняется, т.к.
пакет < ack,i,r
> посылается с r = m когда cr истинно, так что из (2)
и (6)   St > m.

Loss:
(4), (5), (7) и (8) сохраняются, т.к. удаление пакета может фальсифицировать
только их посылку.

Dupl:
(4), (5), (7) и (8) сохраняются, т.к. ввод пакета m применимо только
если m уже был в канале, из чего следует, что заключение данного предложения
было истинным и перед введением.

Time:
(1), (2) и (3) сохраняются, т.к. St, Rt, и Ut[i] может только
уменьшаться, и соединение приемника закрывается, когда Rt становится равным
0. (4) сохраняются, т.к. r может
только уменьшиться, и пакет удаляется, когда его r-поле достигает значения 0. Заметим, что Time уменьшает
все таймеры (включая r-поле
пакета) на одну и ту же величину, значит сохраняет все утверждения вида Xt
> Yt +C, где Xt и Yt -таймеры, и C –
константа. Это показывает, что (5), (6) и (7) сохраняются.           ð

Первое требование к протоколу в том, что каждое слово в
конце концов доставляется или объявляется потерянным. Определим предикат 0k(i)
как

0k(i) ó
error [i] = true \/ q доставил inp [i].

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

P1º  
P0

/\ Øcs
Þ"
i < B: 0k(i)                          (9)

/\ cs Þ" i
< B + Low : 0k(i)                (10)

/\ <data,true,I,w,r > ÎMqÞ"i<B+I:
0k(i)     (11)

/\ cr Þ" i
< B+ Exp : 0k(i)                 (12)

/\ <ack,I,r>Î Mp Þ" i<B+I:
0k(i)                  (13)

Ëåììà 3.11 P1
– инвариант протокола, основанном на таймере.

Äîêàçàòåëüñòâî.
Сначала заметим, что как только 0k(i) стало true для некоторого i,
он никогда больше не становится false. Сначала нет соединения, нет пакетов, и B
= 0, откуда следует, что P1 выполняется.

Ap:
Действие Ap может открыть соединение, но при этом сохраняется
(10), т.к. соединение открывается с Low = 0 и "i < B : 0k(i) выполняется из (9).

Sp:
Действие Sp может послать пакет < data, s, I, w,
r >, но т.к. s
истинно только при I = Low, то это сохраняет (11) из (10).

Rp:
Значение Low может быть увеличено, если принят пакет < ack, I,
r >. Тем не менее, (10)
сохраняется, т.к. из (13) "i
< B + I : 0k(i) выполняется, если получено это подтверждение.

Ep:
Значение Low может быть увеличено, когда применяется действие Ep, но генерация сообщения об ошибке гарантирует,
что (10) сохраняется.

Cp:
Действие Cp обращает cs в false, но оно
применимо только если St < 0 и Low == High. Из (10) следует,
что "i < B+ High :
0k(i) выполняется прежде выполнения Cp, следовательно (9)
сохраняется. Посылка (10) обращается в false в этом действии, и из (5), (6) и
(7) следует, что посылки (11), (12) и (13) ложны; следовательно (10), (11),
(12) и (13) сохраняются.

Rq:
Сначала рассмотрим случай, когда q принимает < data, true,l,w,r>
при не существующем соединении (cr – false). Тогда "i < B+I : 0k(i) из (11), и w
доставляется в действии. Т.к.
w = inp[B+I] из (8),
присваивание Exp := I + 1 сохраняет (12).

       
Теперь рассмотрим случай, когда Exp увеличивается в результате принятия
< data, s,Exp,w,r> при открытом соединении. Из (12), "i < B + Exp : 0k(i)
выполнялось перед принятием, и слово w = Wp[B + Exp] доставляется
действием, следовательно приращение Exp сохраняет (12).

Sq:
Отправление <ack, Exp, m>
сохраняет (13) из (12).

Loss:
Выполнение Loss может только фальсифицировать посылки предложений.

Dupl:
Введение пакета m возможно только если посылка соответствующего
предложения (и, следовательно, заключение) была истинна еще до введения.

Time:
Таймеры не упоминались явно в (9)-(13). Выведение пакета или закрытие процессом
q может только фальсифицировать посылки (11), (12) или  (13).ð

Теперь может быть доказана первая часть спецификации
протокола, но после дополнительного предположения. Без этого предположения
отправитель может быть чрезвычайно ленивым в объявлении слов возможно
потерянными; в Àëãîðèòìе 3.4
указано только, что это сообщение может и не возникнуть в промежуток
времени 2m + R после
окончания интервала для отправления слова, но не указано, что оно вообще должно
появиться. Итак, позвольте сделать дополнительное предположение, что действие Ep на самом выполниться процессом p и в
течение разумного времени, а именно прежде, чем Ut[B + Low] = —2m —R—l.

 

Òåîðåìà 3.12
(Нет потерь) Каждое слово inp доставляется q или объявляется p
как возможно потерянное в течение U+2m+R+l после принятия слова процессом p.

 

Äîêàçàòåëüñòâî.
После принятия слова inp[I], B+High > I
начинает выполняться. Если соединение закрывается в течение указанного периода
после принятия слова inp[I], то B > I, и результат
следует из (9). Если соединение не закрывается в этот промежуток времени и B
+ Low £ I, отчет обо
всех словах из промежутка B + Low..I  возможен ко времени 2m + R после окончания интервала отправления
inp[I]. Из этого следует,
что этот отчет имел место 2m
+ R +l после окончания
интервала отправления, ò.å., U+ 2m +R+l после
принятия. Из этого также следует I < B+ Low, и, значит, слово было
доставлено или объявлено (из (10)).                  ð

Чтобы установить второе требование корректности протокола,
должно быть показано, что каждое принимаемое слово имеет больший индекс (в inp),
чем ранее принятое слово. Обозначим индекс самого последнего доставленного
слова через pr (для удобства запишем, что изначально
pr =-1 and Ut[-1] =  -¥ 
). Определим утверждение P2 как:

P2º
P1

/\ <data,s,i,w,r>  Π Mq
Þ  Ut[B+i] > r -m              (14)

/\ i1 £ i2 < B + High Þ
Ut[i1] £
Ut[i2]                       (15)

/\ cr Þ
Rt ³ Ut[pr] +
m                                  (16)

/\ pr < B + High /\ ( Ut[pr] > -m Þ
cr)                      (17)

/\ cr Þ
B + Exp = pr + 1                                            (18)

Ëåììà 3.13 P2
– инвариант протокола, основанного на таймере.

 

Äîêàçàòåëüñòâî.
Изначально Mq пусто, B + High равно нулю, Øcr выполняется, и
Ut[pr] < -m, откуда
следуют (14)-(18).

Ap:
(15) сохраняется, т.к. каждое новое принятое слово получает значение таймера U,
что из (3) по крайней мере равно значениям таймеров ранее принятых слов.

Sp:
(14) сохраняется, т.к. Ut[B +i] > 0 и пакет отправляется с r=m .

Cp:
(14), (16) и (18) сохраняются, т.к. из (5) è (6) их посылки ложны,
когда  Cp применимо. (15) сохраняется,
т.к. B принимает значение B + High è таймеры не
меняются. (17) сохраняется, т.к. B присваивается значение B + High
è pr è  cr не меняются.

Rq:
(16) сохраняется, т.к. когда Rt устанавливается в R (при принятии
слова) Ut[pr] £
U        из (3), è R³
2m+U. (17) сохраняется, т.к.
pr < B+High, что следует из (8), è cr становится
true. (18) сохраняется, т.к. Exp устанавливается в i +1 è pr
в B + i, откуда следует, что (18) становится true.

Time:
(14) сохраняется, т.к. Ut[B + i] è r уменьшаются на одно и то же число (è выведение
пакета только делает ложной посылку). (15) сохраняется, т.к. Ut[i1]
è Ut[i2] уменьшаются на одну и туже величину. (16)
сохраняется, т.к. cr не становится истинным в этом действии, è Rt
è Ut[pr] уменьшаются на одну и ту же величину. (17) сохраняется,
т.к. его заключение становится ложным только, если Rt становится £ 0, откуда следует (по (16)), что Ut[pr]
становится < -m. (18)
сохраняется, т.к., если  cr не обратился в false, B, Exp è
pr не меняются.

Действия Rp, Ep,
è Sq, не меняют никакие переменные в (14)-(18). Loss
è Dupl сохраняют (14)-(18) исходя из тех же соображений, что и в
предыдущих доказательствах.    ð                                              

Ëåììà 3.14 Из P2
следует, что

< data, s,i1,w,r>
Î Mq Þ (cr \/ B+i1
> pr).

Äîêàçàòåëüñòâî.
По (14), из <data,s,i1,w, r> Î Mq
следует Ut[B+i1] >r -m
> -m.

Если B +i1 £
pr то, т.к. pr < B + High из (15), Ut[pr] > -m, так что из (17) cr  true.         
ð

Òåîðåìà 3.15 (Упорядочение)
Слова, доставляемые q появляются в строго возрастающем порядке в массиве inp.

Äîêàçàòåëüñòâî.
Предположим q получает пакет <data, s,i1,w,r > è доставляет w. Если
перед получением не было соединения, B + i1 > pr
(по Ëåììе 3.14), так что слова w располагается
в inp после позиции pr. Если соединение было, i1
= Exp, значит B+i1 = B+Exp = pr+1 из (18), откуда
следует, что w = inp[pr+1]. ð

 

3.2.3 Обсуждение протокола

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

Качество протокола. Требования Нет потерь
è Упорядочение являются свойствами безопасности, è они
позволяют получить чрезвычайно простое решение, а именно протокол, который не
посылает или получает никакие пакеты, и объявляет каждое слово потерянным. Само
собой разумеется, что такой протокол, который не дает никакой транспортировки
данных от отправителя к приемнику, не является очень "хорошим"
решением.

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

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

Ограниченные порядковые номера. Порядковые номера,
используемые в протоколе, могут быть ограничены, если получить для протокола
результат, аналогичный Ëåììе 3.9 для сбалансированного
протокола скользящего окна [Tel91b, Section 3.2]. Для этого нужно предположить,
что скорость принятия слов (процессом p) ограничена следующим образом:
слово может быть принято только если первое из предыдущих слов имеет возраст по
крайней мере U + 2m+ R
единиц времени. Для этого нужно к действию Ap добавить сторож

{(High < L) V ( Ut[B + High – L] <-R
-2m)}.

Учитывая это предположение, можно показать, что порядковые
номера принимаемых пакетов лежат в 2L-окрестности вокруг Exp, è
порядковые номера подтверждений – в L-окрестности вокруг High.
Следовательно, можно передавать порядковые номера modulo 2L.

Форма действий и
инвариант. Благодаря использованию утверждений, рассуждения относительно
протокола связи уменьшены до (большого) манипулирования формулами.
Манипулирование формулами – "безопасная" методика потому, что каждый
шаг может быть проверен в очень подробно, так что возможность сделать ошибку в
рассуждениях мала. Но есть риск, что читатель может потеряет идею протокола и
его отношение к рассматриваемым формулам. Проблемы проектирования протокола
могут быть поняты и с прагматической, и с формальной точки зрения. Fletcher и
Watson [FW78] утверждают, что упрафляющая информация должна быть
"защищена" в том смысле, что ее значение не должно измененяться
потерей или дублированием пакетов; это – прагматическая точка зрения. При
использовании в проверке утверждений, "значение" информации
управления отражено в выборе специфических утверждений в качестве инвариантов.
Выбор этих инвариантов и проектирование переходов, сохраняющих их, составляет
формальную точку зрения. Действительно, как будет показано, наблюдение Fletcher
и Watson может быть вновь показано в терминах "формы" формул, которые
могут или не могут быть выбран как инварианты протокола, устойчивые к потере и
дублированию пакетов.

Time-e: { d > 0}

begin (* Таймеры в p уменьшаются на d ‘ *)

d ‘ := … ; (*
£ d ‘ £ d ´ (1 + e) *)

forall i do Ut[i] := Ut[i] – d ‘ ;

St := St – d ‘ ;

(*Таймеры в q
уменьшаются на d ‘ *)

d":=…;
(* £ d ” £ d ´ (1 + e)
*)

Rt := Rt – d " ;

if Rt < 0 then delete (Rt,
Exp) ;

(* r -поле
передается явно *)

forall (..,r) Î Mp, Mq do

begin r := r – d,

if
r < 0
then remove packet

end

end

Àëãîðèòì
3.8 Измененное действие Time.

Все инвариантные предложения P2
относительно пакетов имеют форму

"m Î M : A(m)

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

èëè

условие Þ $m Î
M : A(m).

Утверждения, имеющие этй форму могут быть фальсифицированы
потерей или дублированием пакетов, è следовательно не могут
использоваться в
дîêàçàòåëüñòâе
корректности Àëãîðèòìов,
которые должны допускать подобные дефекты.

Подобные же наблюдения применимы к форме инвариантов в
действии Time. Уже было отмечено, что это действие сохраняет все
утверждения формы Xt ³
Yt + C,

где Xt è Yt
-таймеры è C -константа.

P1¢
=   cs Þ St£ S                                            
                       (1¢)

/\ cr Þ
0 < Rt £ R                         
                                         (2′)

/\ "i
< B + High : Ut[i] < U                                                   (3′)

/\ " <.., r > Î
Mp, Mq : 0 < r
£m                                            (4′)

/\ <data, s, i, w, r >Î
M, Þ cs /\ St ³ (1+e)(r+ m+(1+e)R)  (5′)

/\ crÞ
cs /\ St ³ (l+e)((i+e)Rt+m)                                           (6′)

/\ < ack, i, r > Î Mp
Þ cs /\ St >
(1 + e)´r                            (7′)

/\ <data, s, i, w, r > ÎMq,
Þ (w = inp[B
+ i] /\ i < High)       (8′)

/\ Øcs
Þ \/i < B: 0k(i)                                     
                         (9′)

/\ cs Þ
\/i < B + Low : 0k(i)                                                    (10′)

/\<data,true,I,w, r)Î
MqÞ"i<B+I: 0k(i)                               (11′)

/\ cr Þ
"i < B + Exp : 0k(i)    
                                               (12′)

/\ <ack,I, r >Î
MpÞ"i <B+I: Ok(i)                   
                   (13′)

/\ <data, s, i, w, r) ÎMq
Þ Ut[B+i] > (l+e)( r
-m)                (14′)

/\ i1£
i2 < B + High Þ
Ut[i1] < Ut[i2]                        (15′)

/\ cr Þ Rt ³ (1 + e)((l + e) Ut[pr]
+ (1 + e)2 m)                       (16′)

/\ pr < B + High /\ Ut[pr] >-(1+e)mÞ cr                                           (17′)

/\ cr Þ
B + Exp = pr+1                                                           (18’)

Ðèñóíîê
3.9 инвариант протокола с отклонением таймеров.

Неаккуратные таймеры. Действие Time моделирует
идеальные таймеры, которые уменьшаются точно на d в течение d
единиц времени, на на практике таймеры страдают неточности, называемой отклонением.
Это отклонение всегда предполагается e-ограниченным,
ãäå e-известная
константа, что означает, что в течение d 
единиц времени таймер уменьшается на величину d
‘, которая удовлетворяет d /(l
+ e) £ d’
£ d ´
(1 + e). (Обычно e бывает порядка 10-5 или 10-6.)
Такое поведение таймеров моделируется действием Time-e, приведенном в
Àëãîðèòìе 3.8.

Было замечено, что Time сохраняет утверждения
специальной формы Xt ³
Yt + C потому, что таймеры обеих частей неравенства уменьшаются
на в точности одинаковую величину, è из
Xt ³ Yt + C следует (Xt
– d) ³ ( Yt – d)
+ C. Такое жн наблюдение может быть сделано для Time-e. Для действительных чисел Xt, Yt, d, d
‘, d", r, è c,
удовлетворяющих d > 0
è r > 1, из

(Xt ³
r2 Yt + c) /\ ( £ d ‘£ d ´
r) /\  ( £ d ”£ d ´
r)

следует

(Xt-d ‘)³ r2(Yt- d") + c.

Следовательно, Time-e
сохраняет утверждение формы

Xt ³
(1 + e)2 Yt + c.

Теперь протокол может быть адаптирован к работе с
отклоняющимися таймерами, если соответствующим образом изменить инварианты. Для
того, чтобы другие действия тоже сохраняли измененные инварианты, константы R
è S протокола должны удовлетворять

R ³
(1 + e)((1 + e)U + (I + e)2)
è S ³ (1 + e)(2m
+ (1 + e)R).

Исключая измененные константы, протокол остается таким же.
Его инвариант приведен на Ðèñóíêе 3.9.

Òåîðåìà 3.16
P2′- инвариант протокола, основанного на таймере с e-ограниченным отклонением таймера.
Протокол удовлетворяет требованиям Нет потерь и Упорядочение.

 

Упражнения к
главе 3

Раздел 3.1

Óïðàæíåíèå
3.1 Покажите, что сбалансированный протокол скользящего окна не
удовлетворяет требованию окончательной доставки, если из предположений Fl
è FS, выполняется только F2.

Óïðàæíåíèå
3.2 Докажите, что если L = 1 в сбалансированном протоколе скользящего
окна è ap è aq, инициализируются
значениями -lq è -lp, то всегда верно ap+lq
= sp è aq+lp = sq.

Раздел 3.2

Óïðàæíåíèå
3.3 В протоколе, основанном на таймере отправитель может объявить слово
возможно потерянным, когда на самом деле оно было корректно доставлено
приемником.

(1) Опишите выполнение протокола, при котором возникает
этот феномен.

(2)Можно ли спроектировать протокол, в котором
отправитель генерирует сообщение об ошибке в течение ограниченного промежутка
времени, тогда и только тогда, когда слово не доставлено приемником?

Óïðàæíåíèå
3.4 Предположим, что из-за выхода из строя часового устройства, приемник
не может закрыть соединение вовремя. Опишите работу протокола, основанного на
таймере, когда слово теряется без сообщений отправителя.

Óïðàæíåíèå
3.5 Опишите работу протокола, основанного на таймере, в котором приемник
открывает соелинение при принятии пакета с порядковым номером, большим нуля.

Óïðàæíåíèå
3.6 Действие Time-e не
моделирует отклонение в оставшемся времени жизни пакетов. Почему?

 

Óïðàæíåíèå
3.7 Докажите Теорему 3.16.

 

Óïðàæíåíèå
3.8 Инженер сети хочет использовать протокол, основанный на таймере, но
хочет, чтобы отчет о возможно потерянных словах приходил раньше, в соответствии
со следующей модификацией Ep.

Ep:       (* Генерация сообщения
об ошибке для возможно потерянных слов *)

{ Ut[B + Low] < 0 }

begin error[B + Low] := true ; Low := Low +
1 end

 

Продолжает ли тàêèì
îáðàçîì измененный протокол
удовлетворять требованиям Нет потерь и Упорядочение или должны быть сделаны
какие-то изменения? Укажите преимущества и недостатки этих изменений.

4 Алгоритмы маршрутизации

 

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

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

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

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

Критерии для "хороших" методов маршрутизации
включают следующие.

(1) Корректность.
Алгоритм должен доставить каждый пакет, предложенный сети окончательному адресату.

(2) Комплексность.
Алгоритм для вычисления таблиц должен использовать  несколько сообщений, время,
и память (хранение) насколько возможно.

(3) Эффективность.
Алгоритм должен послать пакеты через "хорошие" пути, например, пути,
которые доставляют только маленькую задержку и гарантируют высокую
производительность всей сети. Алгоритм называется оптимальным, если он
использует "самые лучшие" пути.

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

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

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

(6) Справедливость.
Алгоритм должен обеспечить обслуживание каждому пользователю в равной мере.

Эти критерии – иногда
конфликтуют, и большинство алгоритмов выполняет хорошо только их подмножество.

Как обычно, сеть представляется
как граф, где узлы графа – узлы сети, и существует ребро  между двумя узлами,
если они – соседи (то есть, они имеют канал связи между ними). Оптимальность
алгоритма зависит от того, что называется "самым лучшим" путем в
графе; существует, несколько понятий  "самый лучший", каждый с
собственным классом  алгоритмов маршрутизации:

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

(2)Самый
короткий путь. Каждый канал статически назначен  (неотрицательным) весом, и
стоимость пути измеряется как сумма весов каналов в пути. Алгоритм с самой
короткой дорожкой использует путь с самой низкой возможной стоимостью.

 (3)Минимальная 
задержка. Каждый канал динамически означивается весом, в зависимости от
трафика в канале. Алгоритм с минимальной задержкой неоднократно перестраивает
таблицы таким способом, при котором пути с (близкой) минимальной общей
задержкой  выбираются всегда.

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

Следующий
материал обсуждается в этой главе. В Разделе 4.1 будет показано, что, по
крайней мере, для маршрутизации с минимальным переходом и  с самым коротким
путем, можно направить все пакеты предназначенные  d оптимально через дерево
охватов, приложенное к d. Как следствие, отправитель пакета может
игнорироваться, при расчете маршрутизации.

Раздел 4.2
описывает алгоритм, для вычисления таблицы маршрутизации для статической сети с
каналами имеющими вес. Алгоритм распределенно вычисляет самый короткий путь
между каждой парой узлов и в каждом исходном узле первого сосед на пути к
каждому адресату. Недостаток этого алгоритма  в том, что все вычисления должны
быть повторены после изменения топологии сети: алгоритм не масштабируемый.

Алгоритм
изменяемой сети, обсужденный в Разделе 4.3, не страдает из этого недостатка: он
может адаптироваться к потере или восстановлению каналов частичным
перевычислением таблиц маршрутизации. Чтобы  анализ был простым, он реализован
как минимальный переход,  то есть число шагов принимается как стоимость пути.
Возможно  " изменить Netchange алгоритм, для работы с взвешенными
каналами, которые могут теряться или восстанавливаться.

Алгоритмы
маршрутизации Разделов 4.2 и 4.3 используют таблицы маршрутизации (в каждом
узле) с  записями для каждого возможного адресата. Это может  слишком отяготить
больших сетей из маленьких узлов. В Разделе 4.4 будут  обсуждены  некоторые
стратегии маршрутизации,  которые кодируют топологическую информацию в адресе
узла, чтобы использовать более короткие таблицы маршрутизации или меньшее
количество  таблиц. Эти так называемые "компактные" алгоритмы
маршрутизации обычно не используют оптимальные пути. Схема основой – деревом,
интервальная маршрутизация, и префиксная маршрутизация  также будет обсуждена.

Раздел 4.5
обсуждает иерархические методы маршрутизации. В этих методах, сеть разбита на
разделы – кластеры, и различие сделано между маршрутизацией внутри кластера и
маршрутизации между  кластерами. Эта парадигма может использоваться, чтобы
уменьшить количество  решений маршрутизации.

4.1 Адресат-основанная
маршрутизация

Решение маршрутизации, сделанное,
когда пересылается пакет обычно основано только на адресате пакета (и
содержании таблиц маршрутизации), и не зависит от первоначального
отправителя (источника) пакета. Маршрутизация может игнорировать источник и 
использовать оптимальные пути, таковы выводы этого раздела. Выводы не зависят
от выбора частного критерия оптимальности для путей. (Положим, что путь прост,
если он содержит каждый узел только один раз, и путь – цикл, если первый
узел равняется последнему узлу.)

(1)Стоимость
посылки пакета через путь P не зависит от фактического использования
пути, в частности использование ребер P в соответствии с другими
сообщениями. Это предположение позволяет нам оценивать стоимость использования
пути P как функцию пути; таким образом, обозначим стоимость P как
C(P) ÎÂ..

(2) Стоимость
конкатенации двух путей равняется сумме стоимостей составных путей, то есть,
для всякого i= 0,…, k
              C(<uo,u1,…,uk>)=C(<uo,…,ui>)+C(<ui,…,uk>).
Следовательно, стоимости пустого пути  <u0>(это – путь от u0 до u0)
удовлетворяет C(<u0>)
= 0.

(3)Граф не содержит циклов отрицательной стоимости.

( Этот
критерий удовлетворяется критерием самого короткого пути и  критерием 
минимального перехода). Путь от u до v, называется оптимальным,
если не существует никакой путь от u до v с более низкой
стоимостью. Заметьте, что оптимальный путь не всегда единственен; могут
существовать различные пути с той же самой (минимальной) стоимостью.

 

Лемма 4.1.  Пусть u, v ÎV. Если путь из u в v существует в G, тогда и существует
простой путь, который оптимален.

 

Доказательство. Так как количество простых путей
конечное число, то существует простой путь от  u до v, назовем
его So, с наименьшей
стоимостью, т.е., для каждого простого пути P’  из u в v
C(So)£C(P’). Осталось показать что C(So) нижняя
граница стоимостей всех (не простого) путей

Запишем V = {v1,
…, vn}. Следовательно, удаляя
из P циклов, включающие v1,
v1, v2  и т.д., покажем что для каждого пути P из u
в v существует простой путь P’  с C(P’)£ C(P). Положим Po =P, и построим для i = 1,…,
N  путь Pi следующим образом. Если 
vi входит в Pi-1 тогда Pi
= Pi-1. Иначе, запишем  Pi-1 = <uo,
…,uk>. Пусть uj1 будет первым и uj2 будет последним вхождением vi  в Pi-1
и положим

                    Pi
= <uo, . . . , uj1(=uj2),
uj2+1, . . .,uk>

по построению  Pi  –
путь из u к v и содержит все вершины из {v1, …, vn}
только единожды, следовательно PN
-простой путь из u в v. Pi-1  состоит из Pi
и цикла Q= uo, . . . , uj2  следовательно C(Pi-1) = C(Pi) + C(Q). Так как не существует циклов
отрицательного веса, это предполагает C(Pi) £
C(Pi-1)  и, следовательно, C(PN )£
C(P).

По выбору  So,
C(So) £ C(PN,), из которого следует C(So) £
C(P) []

Если G содержит циклы отрицательного веса,  оптимальный
путь не обязательно существует; каждый путь может быть «побежден» другим путем,
который пройдет через отрицательный цикл еще раз. Для следующей теоремы,
примите, что G связный (для несвязных графов,  теорема может применяться
к каждому связному компоненту отдельно).

 

Теорема4.2. Для каждого d Î V существует Td  = (V, Ed)
такое что Ed Í E и такое что для каждой вершины
v Î V,  путь из v к d  в Td  – оптимальный путь от v к d в G.

 

Доказательство. Пусть V = { v1, …, vN
}. Мы индуктивно построим последовательность деревьев Ti = (Vi,
Ei) (для i = 0, …,N)
со следующими свойствами

(1) Каждое Ti – поддерево G, т.е., Vi Ì
V, Ei Ì E, и Ti  – дерево.

(2) Каждое Ti (для i < N) поддерево Ti+1.

(3) Для всех  i > 0,
vi Î Vi  и
d Î Vi.

(4) Для всех wÎVi, простой путь от w к d
в T, – оптимальный путь от w к d в G.

Эти свойства подразумевают, что TN соответствует требованиям для Td.

Конструируя последовательность деревьев, положим Vd = {d} и Eo = Æ . Дерево Ti+1 построим следующим образом. Выберем
оптимальный простой путь  P=<uo,
. . ., uk>  от vi+1 к d, и пусть l будет
наименьшим индексом таким, что ul
Î Ti  (такое l существует, потому что  ul = d Î
Ti ; возможно l = 0).
Теперь:

                           Vi = Vi
È{ uj: j <l}  и  Ei+1 = Ei È {( uj, uj+1)
: j < 1}.

(Построение иллюстративно
представлено на Рисунке 4.1.) Нетрудно видеть что Ti поддерево Ti+1 и что vi+1 Î Vi+1. Чтобы увидеть что Ti+1  дерево, заметим что по построению Ti+1 связный, и число вершин превосходит
число ребер на одно. (To имеет последнее свойство, на каждом
шаге  много вершин и ребер добавлено)

Рисунок 4.1 Построение Ti+1.

Осталось показать, что для всех w Î Vi+1 , (уникальный) путь от w к d в Ti+1 – оптимальный путь от  w к d
в G. Для вершин  w Î Vi Ì
Vi+1  это следует, потому
что Ti  поддерево Ti+1 ;  путь от w к d в Ti+1   точно такой же, как путь в Ti, который оптимален. Теперь пусть w = uj, j < l  будет вершиной в Vi+1 \V,.  Запишем Q для пути
от ui к  d в Ti, тогда в Ti+1  uj
соединена с  d через путь <uj, . . . , ul>
соединенный с Q, и осталось показать, что этот путь оптимальный в G.
Во-первых, суффикс P’ = <ul,
. . . , uk>  в P 
оптимальный путь от ul  до d,
т.е., C(P’) = C(Q): оптимальность Q подразумевает что C(P’)
³C(Q), и C(Q)<
C(P’) подразумевает (добавлением стоимости пути) что путь <uo, . . . , ul> соединен с Q имеющий меньший
путь, чем P, противоречащий оптимальности  P. Теперь положим, что
R из uj к d
имеет меньшую стоимость, чем путь <uj,
. . . , ul>
соединенный с Q. Тогда, по предыдущим наблюдениям, R имеет
меньшую стоимость, чем суффикс <uj,
. . . , uk>   P,
и это предполагает что путь <uo,
. . . , uj>
соединенный с  R имеет меньшую стоимость,  чем P, противоречащий
оптимальности  P.                                                    Ž

Дерево охвата, приложенное к d , называется деревом
стока для d, и дерево со свойством, данным в Теореме 4.2 ,
называется оптимальным деревом стока. Существование оптимальных деревьев
стока  не является компромиссом оптимальности, если только алгоритмы
маршрутизации  рассматриваются, для которого механизм пересылки, как в
Алгоритме 4.2. В этом алгоритме, table_lookupu локальная процедура с одним параметром, возвращая соседа u
(после консультации с таблицами маршрутизации). Действительно, поскольку все
пакеты для адресата d могут быть направлены оптимально используя дерево
обхвата, приложенное к d, пересылка оптимальна, если, для всего u¹d, table_lookupu(d)  возвращает отца u в  дереве
охвата Td.

Когда механизм пересылки имеет эту форму, и никакие
(дальнейшие) изменения топологии не происходят, корректность таблиц
маршрутизации может быть удостоверена, используя следующий результат. Таблицы
маршрутизации, как говорят,  содержат цикл (для адресата d), если
существуют узлы u1, . . . , uk такие, что для всех i , ui ¹d,
для всех i < k, table_lookupu(d)
= ui+1, и table_lookupu(d) = uj+1..
Таблицы, как говорят,  являются свободным от циклов, если они не содержат
циклов для любого d.

(* Пакет с адресатом d был получен или сгенерирован в
узле u *)

if d=u

          then доставить «местный» пакет

          else послать пакет к table_lookupu (d)

 

Алгоритм 4.2
Адресат-основанная пересылка (для узла u).Лемма 4.3 Механизм пересылки доставляет каждый
пакет  адресату, тогда и только тогда когда  таблицы маршрутизации
цикл-свободны.

 

Доказательство. Если таблицы содержат цикл для
некоторого адресата d,  пакет для d никогда не будет доставлен,
если источник – узел в цикле.

Примем, что  таблицы цикл-свободны и позволяют пакету с
адресатом d (и источник uo)
быть посланным через uo, u1, u2,
. .. если один встречается дважды в этой последовательности, скажем ui = uj,
тогда таблицы содержат цикл, а именно < ui  …, uj>
противореча предположению, что таблицы являются цикл-свободными. Таким образом,
каждый узел входит единожды, что подразумевает, что эта последовательность
конечна, заканчивающаяся, скажем, в узле Великобританию uk (k < N). Согласно процедуре пересылки
последовательность может  заканчиваться только в d , то есть, uk = d, и пакет достиг адресата за не больше
чем N — 1 шагов

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

 

Ветвящаяся маршрутизация с минимальной задержкой. При
маршрутизации через пути с минимальной задержкой требуется, и задержка канала
зависит от использования (таким образом, предположение (1) в начале этого
раздела не имеет силу), стоимость использования пути не может просто быть
оценена как функция этого единственного пути. Кроме того, трафик на канал
должен быть принят во внимание. Избегать скопления пакетов (и возникающую в
результате этого задержку) на пути, обычно необходимо посылать пакеты, имеющие
ту же самую пару исходный-адресат через различные пути; трафик для этой пары
"распределяется" в один или большее количество узлов промежуточного
звена как изображено в Рисунке 4.3. Методы маршрутизации, которые используют различные
пути к одному адресату,  называются много-путевыми или ветвящимися методами
маршрутизации. Потому что ветвящиеся методы маршрутизация  являются, обычно,
очень запутанными, они не будет рассматриваться в этой главе

Рисунок 4.3 Пример
буферизованной маршрутизации.

4.2 Проблема
кротчайших путей всех пар

Этот раздел обсуждает алгоритм Toueg [Tou80a] одновременного
вычисления  таблицы маршрутизации для всех узлов в сети. Алгоритм вычисляет для
каждой пары (u, v) узлов длину самый короткий пути от u до v
и сохраняет первый канал такого пути в u. Проблема вычисления самого
короткого пути между любыми двумя узлами графа известна как  проблема
кротчайшего пути всех пар. Распределенный алгоритм Toueg для этой проблемы
основан на централизованном  алгоритме Флойда-Уошалла [CLR90, Раздел 26.4]. Мы
обсудим алгоритм Флойда-Уошалла в Подразделе 4.2.1, и впоследствии алгоритм
Toueg в Подразделе 4.2.2. Краткое обсуждение некоторых других алгоритмов для
проблемы кротчайших путей всех пар следует в Подразделе 4.2.3
..                                

4.2.1 Алгоритм
Флойда-Уошала

Пусть дан взвешенный граф G = (V, E) ,
где вес ребра uv дан wuv
. Не обязательно допускать что wuv=
wvu , но допустим, что граф
не содержит циклов с общим отрицательным весом. Вес пути  < uo, …, uk> определяется как  .
Дистанция от u до v, обозначенная d(u, v),
наименьший вес любого пути от u к v (¥  если нет такого пути). Проблема кротчайших путей всех пар
– вычисление d(u, v) для каждых u и v.

Для вычисления всех расстояний, алгоритм  Флойда-Уошала
использует понятие  S-путей; это пути, в которых все промежуточные
вершины принадлежат к подмножеству S из V.

 

Определение 4.4.  Пусть S – подмножество V. Путь <
uo  …, uk> -S-путь если для любого i, 0 <i <
k,  uj Î S.  S-расстояние от u до v, обозначенное dS(u.
v), наименьший вес любого S-пути от u до v (¥  если такого пути нет).

Алгоритм стартует рассмотрением всех Æ-путей, и увеличивая вычисления S-путей для
больших подмножеств S, до тех пор пока V-пути будут рассмотрены.
Могут быть сделаны следующие наблюдения.

 

Утверждение 4.5 Для всех u и S, dS(u,
u) = 0. Более того, S-пути удовлетворяют следующим правилам для u¹ v.

(1) Существует Æ
-путь от u к v тогда и только тогда когда uv ÎE.

(2) Если uv Î
E тогда dS(u, v) = wuv  иначе dS(u,
v) =¥ .

(3) Если  S’=S È{w}
тогда простой S’-путь от и к v – S-путь от u к v
или S-путь от u к w соединенные  S-путем от w к v.

(4) Если S’ = S È{w}
тогда dS’ (u, v)=min(dS (u, v), dS (u, w)+ dS
(w, v)).

(5) Путь от u до v существует тогда и только тогда когда
V-путь от u к v существует

(6) d(u, v)= dV (u, v),

 

Доказательство. Для всех u и S  dS
(u, u) £.0 по причине того,
что пустой путь (состоящий из 0 ребер) это  S-путь от u к u
с весом 0. Нет путей, имеющих меньший вес, потому что G не содержит
циклов отрицательного веса, таким образом, dS (u, u) = 0.

 

Для
(1):  Æ -путь не содержит
промежуточных узлов,  так  Æ –
путь от u к v

состоит
только из канала  uv.

Для
(2): следует непосредственно из (1).

Для
(3): простой S’-путь от u к v содержит узел w
единожды, или 0 раз как промежуточный. Если он не содержит w как
промежуточную вершину он  S-путь, иначе он – конкатенация двух S-путей, один к 
w и один из w.

Для(4):
Это можно доказать применив  Лемму 4.1 . Получим что  (если S’-путь от u
в v существует) это  простой S’ -путь длиной dS’(u,
v) от u к v, такой, что  dS’(u, v) = min(dS
(u, v), dS (u, w) + dS (w, v) ) по (3).

Для (5):
каждый  S-путь – путь, и обратно.

Для (6):
каждый  S-путь – путь, и обратно, следовательно, оптимальный V-путь  также оптимальный
путь.

 

_____________________________________________________________________

begin (* Инициализация S = Æ  и D = Æ-дистанция *)

       S:=0;

forall u,v do

if u = v then  D[u, v] := 0

                           else

if uv Î
E then D[u, v] := wuv

                                                            
 else D[u. v] := ¥ 
;

      (* Расширим S  «центральными точками» *)

      while S ¹ V do

                (* Цикл инвариантен: "u, v : D[u, v] = dS (u, v) *)

                begin выбрать  w из V
\ S ;

                          (* Выполнить глобальную w-центровку
*)

forall u Î
V do

                                 (* Выполнить
локальную w-центровку u *)

forall  v ÎV
do

                                          D[u. v] :=
min ( D[u, v], D[u, w] + D[w, v] ) ;

                                         S:=S È{w}

                end   (*"u, v : D[u, v] = dS (u, v)*)

 end

 

Алгоритм4.4 Алгоритм
Флойда-Уошалла.

Используя Утверждение 4.5 не сложно разработать алгоритм 
"динамического программирования" для  решения проблемы кротчайших
путей всех пар; смотри см. Алгоритм 4.4. Алгоритм вначале считает 0-пути, и,
увеличивая, вычисляет  S-пути для больших множеств S (увеличивая  S  
"центральными" кругами), до тех пор, пока  все пути не будут
обсуждены.

 

Теорема 4.6 Алгоритм 4.4 вычисляет расстояние
между всеми парами узлов за Q(N3)
шагов.

 

Доказательство. Алгоритм начинает с D[u, v] = 0,
  если u = v, D[u, v] = wuv , если uv Î E и D[u, v] = ¥  в другом случае, и S = 0.
Следуя из Утверждения 4.5, частей (1) и (2), "u,
v имеет силу  D[u, v] = dS (u, v) . В
центральной окружности с центральной вершиной w  множество S
расширено узлом w, и означивание  D[u, v] гарантирует (по частям
(3) и (4) утверждения) что утверждение "u,
v : D[u, v] = dS(u, v)  сохранено как инвариант цикла.
Программа заканчивает работу, когда S = V, т.е., (по частям (5) и
(6) утверждения и инварианту цикла)  S-расстояние эквивалентно
расстоянию.

Главный цикл  выполняется N  раз, и содержит N2
операций (которые могут быть выполнены параллельно или последовательно),
откуда и следует временная граница  данная теоремой.ˆ

_____________________________________________________________________                                                   

var Su    : множество вершин;

       Du   : массив весов;

       Nbu : массив вершин;

begin Su :=Æ  ;

      forall v Î
V do

            if v = u

                  then begin Du [v]
:=0 ; Nbu[v] := udef  end

            else if v Π Neighu

                  then begin Du[v] :=
wuv ; Nbu[v] := v end

            else begin Du[v] := ¥ ; Nbu[v] := udef
end ;

      while Su¹ V do

           begin выбрать w из V \ Su
;

                     (* Все вершины должны побывать вершиной
w *)

                      if u == w

                             then "распространить
таблицу Dw"

                             else  
"принять таблицу Dw"

                       forall v Î V do

                             if Du[w] +
Dw[v] < Du[v] then

                                  begin Du[v]:=
Du[w] + Dw[v] ;

                                             Nbu[v]
:= Nb[w]

                                  end;

                                  Su := Su U {w}

                       end

          end;

Алгоритм 4.5 Простой алгоритм (Для узла u).

4.2.2 Алгоритм
кротчайшего пути.(Toueg)

Распределенный алгоритм вычисления  таблиц маршрутизации бал
дан Toueg [TouSOa], основанный на алгоритме Флойда-Уошалла описанном в
предыдущей части. Можно проверить что алгоритм Флойда-Уошалла подходит для этих
целей, т.е., что  его ограничения реалистичны для распределенных систем. Наиболее
важное ограничение алгоритма что граф не содержит циклов отрицательного веса.
Это ограничение действительно реально для распределенных систем,  где обычно
каждый отдельный канал означен положительной оценкой. Даже можно дать более
строгое ограничение; смотри A1 ниже. В этой части даны следующие ограничения.

A1. Каждый цикл в сети имеет положительный вес.

A2. Каждый узел в сети знает обо всех узлах
(множество V).

A3. Каждый узел знает какой из  узлов его сосед  (хранится
в  Neighu для узла u) и веса своих выходящих каналов.

Корректность алгоритма  Toueg (Алгоритма4.6) будет более
просто понять если мы сперва обсудим предварительную версию  алгоритма ,
"простой алгоритм" (Алгоритм 4.5).

Простой алгоритм. Для достижения распределенного
алгоритма переменные и операции алгоритма Флойда-Уошала распределены по узлам
сети. D[u, v] – переменная принадлежащая узлу  u; по
соглашению, это будет выражено описанием  Du[v] .Операция,
означивающая  Du[v], должна быть выполнена узлам u, и
когда необходимо значение переменной узла w, это значение должно быть послано
u. В алгоритме Флойда-Уошала все узлы должны использовать информацию из
«центрального» узла (w в теле цикла), который посылает эту информацию к
всем узлам одновременно операцией "распространения". В заключение,
алгоритм будет расширен операцией  для поддержки не только длины кратчайших S-путей
(как в переменной Du[v]), но также первый канал такого пути
(в переменной Nbu[v]).

Утверждение что циклы сети имеет положительный вес может
использоваться чтобы показать  что не существует циклов в таблицах
маршрутизации.

 

Лемма 4.7 Пусть даны  S и w и выполняется:

(1) для всех  u :Du[w] = dS(u,
w) и

(2) если dS(u, w) < ¥  и  u ¹ w, то Nbu[w]- первый канал кратчайшего  S-пути
к w.

 

Тогда  направленный граф Tw = (Vw,
Ew), где (u Î Vw
Û Du[w]<¥ ) и (ux ÎEw Û
(v¹wÙNbu[w]=x)) –  дерево с
дугами направленными к  w.

 

Доказательство. Во-первых, заметим, что если Du[w]
< ¥  для u ¹ w, то Nbu[w] ¹ udef и .  Таким образом
для каждого узла u Î Vw,
u ¹ w существует
узел x для которого Nbu[w] = x, и  x Î Vw.

Для каждого узла u¹
w в Vw существует единственное ребро в Ew,
такое что число узлов в Tw превышает количество ребер на
единицу и  достаточно показать что  Tw не содержит циклов.
Так  ux ÎEw
подразумевает что dS(u, w) =wux+ dS(x, w), существование
цикла <uo, u1, .. ., uk>
в Tw подразумевает что

                        dS(uo,
w) = wuo u1 + wu1 u2 + … + wuk-1
uou+ dS(uo, w),

 т.е.,         0 = wuo u1 + wu1
u2 + … + wuk-1 uou

что противоречит предположению, что каждый цикл имеет
положительный вес.   ‰

Алгоритм Флойда-Уошала теперь может быть просто преобразован
в Алгоритм  4.5. Каждый узел инициализирует свои собственные переменные и
исполняет N итераций основного цикла. Этот алгоритм не является
окончательным решением, и он не дан полностью, потому что мы не описали, как
может бать произведено (эффективно) распространение таблиц центрального узла.
Пока это можно использовать как гарантированное, поскольку операция
"распространить таблицу Dw" выполняется узлом w,
а операция "принять таблицу Dw"  выполняется
другими узлами, и каждый узел имеет доступ к таблице Dw.

Некоторое внимание должно быть уделено операции
"выбрать w из V \ S", чтобы  узлы выбирали
центры в однообразном порядке. Так как  все узлы знают V заранее, мы
можем запросто предположить, что узлы выбираются в некотором предписанном
порядке (на пример, алфавитный порядок имен узлов).

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

Теорема 4.8 Алгоритм 4.5 завершит свою работу в
каждом узле после  N итераций основного цикла. Когда алгоритм завершит свою
работу в узле u  Du[v] = d(u, v), и  если путь из u в v существует 
то Nbu[v] первый канал кротчайшего пути из u в v, иначе  Nbu[v]
= udef.

 

Доказательство. Завершение и корректность Du[v]
по завершении работы  следует из корректности алгоритма Флойда-Уошала (теорема
4.6). Утверждение о значении  Nbu[v] справедливо потому что Nbu[v]
перевычисляется каждый раз  когда означивается Du[v] .‰

 Усовершенствованный алгоритм. Чтобы сделать
распространение в Алгоритме 4.5 эффективным, Toueg заметил, что узел u
для каждого Du[w] = ¥ 
на старте  w-централизованного обхода не меняет свои таблицы в течение
всего w-централизованного обхода.  Если Du[w] = ¥ , то Du[w] + Dw[v]
< Du[v] не выполняется для каждого узда v.
Следовательно, только узлы, принадлежащие  Tw (в начале w-централизованного
обхода) нуждаются в получении таблиц w, и операция распространения может
стать более эффективной рассылая Dw только через каналы, принадлежащие
дереву Tw. Таким образом, w рассылает Dw
своим  сыновьям в Tw и каждый узел в Tw 
который принимает таблицу (от своего отца в Tw) пересылает её
к своим сыновьям в Tw.

____________________________________________________________________

var  Su   : множество узлов ;

       Du  : массив весов;

      Nbu : массив узлов ;

begin

      Su := Æ 
;

      forall v Î V do

             if v = u

                  then begin Du[v]
:= O ; Nbu[v] := udef end

             else if v Π Neighu

                  then begin Du[v]
:= wuv ; Nbu[v] := v end

             else begin Du[v] := ¥  ; Nbu[v] := udef
end ;

       while Su ¹ V do

             begin выбрать w из V \
Su ;

                       (* Построение дерева Tw
*)

                       forall
x Î Neighu
do

                            if Nbu[w]
= x then send < ys, w> to x

                                                   else
send < nys, w > to x ;

                            num_recu := O
; (* u должен получить |Neighu| сообщений *)

                           while num_recu
< |Neighu| do

                                     begin получить
< ys, w > или  < nys, w > сообщение ;

                                                num_recu
:= num_recu + 1

                                     end;

                            if Du[w]
< ¥  then (* участвует в
центр. обходе*)

                                     begin if u¹ w

                                                         
then  получить <dtab,w,D> от Nbu[w] ;

                                               forall x Î
Neighu do

                                                       
if < ys, w > было послано от x

                                                                
then послать < dtab, w, D>) к x; ;

                                              forall v Π
V do (* локальный  w-центр *)

                                                         if
Du[w] + D[v] < Du[v] then

                                                                 
begin Du[v] := Du[w] + D[v] :

                                                                            Nbu[v]
:= Nbu[w]

                                                                 
end

                                      end;

                             Su := Su
È {w}

               end

     end

Алгоритм 4.6 Алгоритм Тoueg (для узла u).

_____________________________________________________________________

В начале w-централизованного раунда узел u с Du[w]
< ¥  знает кто его отец (в Tw)
, но не знает кто его сыновья. Поэтому каждый узел v должен послать сообщение
к каждому своему соседу u, спрашивая  u является ли v
сыном  u в Tw. Полный  алгоритм дан как Алгоритм 4.6.
Узел может участвовать в пересылке таблицы w когда известно что  его
соседи являются его сыновьями в Tw. Алгоритм использует три
типа сообщений:

(1) <ys,w>
сообщение  <ys обозначение для "your son">  u посылает к
x; в начале  w-централизованного обхода если x отец u
в Tw.

(2) <nys, w>
сообщение <nys обозначение для "not your son"> u
посылает x в начале w-централизованного обхода если x не
отец u в Tw

(3) <dtab,
w, D> сообщение посылается в течение w-централизованного
обхода через каждое ребро Tw чтобы переслать значение Dw 
к каждому узлу который должен использовать это значение.

Полагая сто вес (ребра или пути) вместе с именем узла можно
представить W битами, сложность алгоритма показана следующей теоремой.

Теорема 4.9 Алгоритм 4.6 вычисляет для каждых  u
и v дистанцию от u к v, и, если эта дистанция конечная,
первый канал. Алгоритм обменивается 0(N) сообщениями на канал,, 0(N*|E|) сообщений
всего, O(N2W) бит на канал, O(N 3W) бит всего, и
требуется  0(NW) бит хранения на узел.

 

Доказательство. Алгоритм 4.6 выведен от Алгоритма
4.5, который корректен.

Каждый канал переносит два ( < ys, w> или <
nys, w> ) сообщений (одно в каждом направлении) и не более одного <dtab,
w, D > сообщения в w-централизованном обходе, который включает
не более 3N сообщений на канал.  < ys, w > или < nys, w
> сообщение содержит O(W) бит и <dtab, w, D > сообщение
содержит O(NW) бит, что и является границей для числа бит на канал. Не
более N2 < dtab, w,D> сообщений и 2N – |E|
(<ys,w> и <nys,w> ) сообщений обмена, и того
всего O(N2 – NW +2N-|E|-W) = O(N3W) бит.
Таблицы Du и Nbu хранящиеся в узле u
требуют 0(NW) бит.‰

                                                            

В течение w-центализованного обхода узлу разрешено
принимать и обрабатывать сообщения только данного обхода, т.е., те которые
переносят параметр w. Если каналы удовлетворяют дисциплине FIFO тогда сообщения
<ys,w> и <nys, w> прибывают первыми, по одному через
каждый канал, и затем сообщение < dtab, w, D > от Nbu[
w] (если узел в Vw). Таким образом возможно,
аккуратно программируя, опустить параметр w во всех сообщениях если
каналы удовлетворяют дисциплине FIFO. Если каналы не удовлетворяют дисциплине
FIFO возможно что сообщение с параметром w’ придет пока узел ожидает
сообщения для обхода w, тогда как w’ становится центром после  w. 
В этом случае параметр используется  чтобы различить сообщения  для каждого
централизованного обхода, и локальная буферизация ( в канале и узле) должна 
использоваться для отсрочки выполнения w’-сообщения.

Toueg дал дальнейшую оптимизацию алгоритма, полагаясь на
следующий результат. (Узел u2 потомок  u1
если u2 принадлежит поддереву  u1)

 

Лемма 4.10 Пусть u1¹ w, и пусть u2 
потомок   u1 в Tw, в начале w-централизованного обхода,
если u2  изменит своё расстояние до  v во время w-централизованного
обхода, тогда и  u1 изменит своё расстояние до v в этом же обходе.

 

Доказательство. Так как  u2 потомок
u1 в Tw :

                                    dS(u2,
w) = dS (u2, u1) + dS (u1,
w).             (1)

  Так как  u1 Π S:

                                    dS(u2,
v) £ dS (u2,
u1) + dS (u1,v).                
(2)

   Узел  u2 изменит Du2 [v]
в данном обходе тогда и только тогда когда

                                    dS(u2,
w) + dS (w, v) < dS (u2, v).                  (3)

   Применяя (2), и затем (1), и вычитая dS(u2,
u1), мы получим

                                   dS(u1,
w) + dS (w, v) < dS (u1, v)                   
(4)

значит  u1 изменит Du1 [v]
в этом обходе.‰

В соответствии с этой леммой, Алгоритм 4.6 может быть
модифицирован следующим образом. После получения таблицы Dw,
(сообщение <dtab, w,D>) узел u вначале выполняет
локальные w-централизованные операции, и затем рассылает таблицы своим
сыновьям в Tw. Когда пересылка таблицы закончилась достаточно
переслать те ссылки  D[v] для которых Du[v] изменилась
в течение локальной w-централизованной операции. С этой модификацией
таблицы маршрутизации не содержат циклов не только между централизованными
обходами (как сказано в Лемме 4.7), но также в течение централизованных
обходов.

 

4.2.3
Обсуждение и Дополнительные Алгоритмы

Представление алгоритм Toueg  предоставило пример как
распределенный алгоритм может быть получен непосредственным образом из
последовательного алгоритма. Переменные последовательного алгоритма
распределены по процессам, и любое означивание переменной x (в
последовательном алгоритме) выполняется процессом владеющим x. Всякий
раз когда  ознaчивающее выражение содержит ссылки на переменные  из других
процессов, связь между процессами потребуется для  передачи значения и
синхронизации процессов. Специфические свойства последовательного алгоритма
могут быть использованы для минимизации числа соединений.

Алгоритм Toueg прост для понимания, имеет низкую сложность,
и маршрутизирует через оптимальные пути; его главный недостаток в его  плохая
живучесть. Когда топология сети изменилась все вычисления должны произвестись
заново.

Во-первых, как ранее говорилось, однообразный выбор всеми
узлами следующего центрального узла (w) требует чтобы множество
участвующих узлов было известно заранее. Так как это в основном не известно
априори, исполнение расширенного распределенного алгоритма вычисления этого
множества (на пример  алгоритм Финна, Алгоритм 6.9) должно предшествовать
исполнению алгоритма Toueg.

Во-вторых, алгоритм Toueg основан на повторяющимися
применениями уникальности треугольника d(u, v) £ d(u, w) + d(w, v). Оценивание правой стороны ( u)
требует информацию о d(w, v), и эта информация  в часто удалена,
т.е., не доступна ни в u ни в любой из его соседей. Зависимость
от удаленных данных делает необходимым транспортирование информации к удаленным
узлам, которые могут быть исследованы в алгоритме Toueg (часть распространения).

Как альтернатива, определенное ниже равенство для d(u, v)
может использоваться в алгоритмах для проблем кротчайших путей:

                      ì       
0                             если u=v

    d(u,v)=      í                              
                                             (4.1)

                      î        
wuw+d(w,v)            иначе   

Два свойства этого равенства делают алгоритмы основанные
на   этом отличными от алгоритма Toueg.

(1) Локальность
данных. Во время оценивания правой стороны равенством (4.1), узлу  u
необходима только информация доступная локально (именно, wuw)
или в соседях (именно, d(w, v)). Транспортирование данных между удаленными
вершинами избегается.

(2) Независимость
пункта назначения.  Расстояния до v (именно, d(w, v) где w
сосед  u) только нуждаются в вычислении расстояния от u в v. 
Таким образом, вычисление всех расстояний до фиксированного пункта назначения vo
может происходить независимо от вычисления расстояния до других узлов, и
также, может бать сделано обособленно.

В завершение этой части обсуждены два алгоритма основанные
на равенстве, а именно алгоритмы Мерлина-Сигалла и Чанди-Мизра. Не смотря на
преимущества от локальности данных, сложность соединений этих алгоритмов не
лучше алгоритма Toueg. Это из-за независимости пункта назначения введенного равенством(4.1);
очевидно, использование результатов для других пунктов назначения (как сделано
в алгоритме Toueg) более выгодный прием чем локальность данных.

Если это не ведет к уменьшению сложности соединений, тогда
каково значение локальности данных? Уверенность в удаленных данных требует
повторных распространений если данные могли измениться из-за топологических
изменений сети. Доведение до конца этих распространений  (с возможными новыми
топологическими изменениями в течение распространения) вызывает нетривиальные
проблемы с дорогими решениями  (см., на пример, [Gaf87]). Более того, алгоритмы
основанные на равенстве 4.1 могут быть более легко адаптированы к
топологическим изменениям. Оно служит примером в части  4.3, где подробно разобран
такой алгоритм.

Алгоритм  Мерлина-Сигалла. Алгоритм предложенный
Мерлином и Сигаллом [MS79] вычисляет таблицы маршрутизации для каждого пункта
назначения абсолютно обособленно; вычисления для различных пунктов назначения
не оказывают влияния друг на друга. Для пункта назначения v, алгоритм
начинает работу с дерева Tv с корнем в v, и повторно
перевычисляет это дерево с тем чтобы оно стало оптимальным деревом стока для  v.

Для пункта назначения v, каждый узел u содержит
оценку расстояния до v (Du[v]) и соседа через которого
пакет для  u пересылается (Nbu[v]), который также
является отцом u в Tv. В период перевычисления каждый
узел u посылает свою оценку расстояния, Du[v], к всем
соседям  исключая Nbu[v] (в < mydist, v, Du[v]>
сообщении). Если узел u получает от соседа w сообщение
<mydist,v,d> и если d+wuv < Du[v],
u изменит Nbu[v] на w и Du[v] на
d + wuv. Период перевычисления контролируется узлом v
и требует обмена двумя сообщениями в W бит на каждый канал.

В [MS79] показано что после  i периодов
перевычислений все кротчайшие пути в более чем i шагов будут корректно
вычислены, так что после  N раундов все кротчайшие пути будут вычислены.
Кротчайшие пути в каждый пункт назначения вычисляются выполнением алгоритма
независимо для каждого пункта назначения.

Теорема 4.11 Алгоритм  Мерлина и Сигалла вычисляет
таблицы маршрутизации кротчайших путей с обменом  0(N2) сообщениями
на канал, 0(N2 W) битами на канал, 0(N2 |E|) сообщениями
всего, и 0(N2|E|W) битами всего.

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

 

Алгоритм Чанди—Мизра. Алгоритм предложенный Чанди и
Мизра [CM82] вычисляет все кротчайшие вычисляет до одного пункта назначения
используя парадигму диффузивных вычислений (распределенные вычисления
которые инициируются одним узлом, и другие  узлы присоединяются только после
получения сообщения).

Вычисление, для всех узлов,
расстояния до узла vo (и привилегированного исходящего
канала), каждый узел u начинает с Du[vo] = ¥  и ждет получения сообщений. Узел vo
посылает <mydist,vo,0> сообщение всем соседям. Когда же
узел u получает сообщение <maydist,vo,d>
от соседа w, где d + wuw < Du[vo],
u заносит значение  d+wuv  в Du[vo]
и посылает сообщение < mydist, vo, D Du[vo]>
всем соседям; смотри Алгоритм 4.7.

var Du[vo]   : вес    init
¥  ;

       Nbu[vo] : узел  init
udef ;

Только для узла vo :

      begin Du[vo] := 0
;

                forall w Î Neighvo do
послать < maydist, vo, 0> к w

       end

Обработка сообщения < maydist, vo,
d> от соседа w узлом u:

        { <mydist, vo,d>
Î Mwv }

        begin получить <mydist,vo,d> 
от w ;

                     if  d + wuw < Du[vo] 
then

                          begin Du[vo]
:= d+wuw ;  Nbu[vo] := w
;

                                  
forall  x Î Neighu do послать < maydist,
vo, Du[vo]> к x

                          end

          end

 

Алгоритм 4.7 Алгоритм
Чанди-Мизра (для узла u).

Не трудно показать что Du[vo]
всегда верхняя граница для d(u, vo), т.е., d(u,vq) £ Du[vo]
инвариант алгоритма; см. упражнение 4.3. Чтобы продемонстрировать чти алгоритм
вычисляет расстояния верно, нужно показать что в конечном счете достигнется
конфигурация в которой Du[vo] £ d(u, vo) для
каждого u. Мы дадим  доказательство этого свойства используя
предположение допущения слабой справедливости, а именно, что каждое сообщение
которое посылается в конечном счете получено в каждом вычислении.

 

Теорема 4.12 В каждом вычислении  Алгоритма 4.7
достигнется конфигурация в которой для каждого узла u, Du[vo]
£ d(u, vo).

 

Доказательство. Зафиксируем оптимальное дерево стока T
для vo и обозначим остальные узлы  v1 … vN-1
таким образом что  если vi, отец узла vj,
тогда i < j. Пусть C вычисление; можно показано индукцией по  j
что для каждого j £ N—
1  достигнется конфигурация в которой, для каждого i £ j, Dvi[vo]
£ d(vi,
vo). Заметим что  Dvi[vo] никогда
не увеличивается в алгоритме; таким образом если Dvi[vo]
£ d(vi, vo)
содержится в некоторой конфигурации то она лучшая конфигурация из всех.

Случай j = 0:  d(vo, vo) =
0, и Dvo[vo] = 0 после выполнения
инициализационной части узлом  vo, , таким образом Dvo[vo]£ d(vo, vo)
содержится после этого выполнения.

Случай j + 1: Допустим что достигнется
конфигурация в которой для каждого i £
j, Dvi[vo]£d(vi,
vo), и рассмотрим  узел vj+1. Имеется
кротчайший путь vj+1, vi, …, vo
длины d(vj+1, vo) от vj+1
до vo, где  vi отец  vj+1
в T, отсюда i £
j. Следовательно, по индукции, достигается конфигурация в которой Dvi[vo]£ d(vi, vo).
Всякий раз когда  Dvi[vo] уменьшится, vi
посылает сообщение < mydist, vo, Dvi[vo]>
своим соседям, отсюда сообщение < mydist, vo,d>посылается
к vj+1 по крайней мере однажды с  d £ d(vi,vo).

По предположению, это сообщение принимается в C узлом
vj+1. Алгоритм подразумевает что после получения этого
сообщения хранится Dvi[vo] £ d +  ,
и выбор  i подразумевает что  d +  £ d(vj+1, vo).

Полный  алгоритм также включает механизм с помощью которого
узлы могут определить окончание вычисления.; сравним с замечанием об алгоритме
Netchange  в начале части  4.3.3. Механизм для определения завершения является
вариацией алгоритма Дейкстры-Шолтена обсужденного в  8.2.1.

Алгоритм отличается от алгоритма Мерлина-Сигалла двумя
вещами. Во-первых, нет "отца" узла u которому не посылаются
сообщения типа <mydist,.,.>. Эта особенность алгоритма 
Мерлина и Сигалла гарантирует что таблицы всегда не содержат циклов, даже в
течение вычислений и при наличии топологических изменений. Во-вторых, обмен
сообщениями < mydist,.,. > не координируется в раундах, но существует
отслеживание завершения, который влияет на сложность не лучшим образом.

Алгоритм может потребовать экспоненциальное количество
сообщений для вычисления путей до одного пункта назначения vo.
Если стоимости всех каналов равны (т.е., рассматривается маршрутизация с минимальным 
количеством переходов) все кротчайшие пути к  vо вычисляются
используя O(N  |E|) сообщений ( O(W) бит каждое), руководствуясь
следующим результатом.

Теорема 4.13 Алгоритм  Чанди и Мизра вычисляет
таблицы маршрутизации с минимальным количеством шагов с помощью обменов 0(N2)
сообщениями (N2W) бит на канал, и 0(N2|E|) сообщений и
0(N2 |E| W) бит всего.

Преимущество алгоритма  Чанди и Мизра над алгоритмом 
Мерлина и Сигалла в его простоте, его меньшей пространственной сложности, и его
меньшей временной сложности.

 

4.3 Алгоритм
Netchange

Алгоритм Таджибнаписа  Netchange [Taj77] вычисляет таблицы
маршрутизации которые удовлетворяют мере "минимальное количество
шагов". Алгоритм подобен алгоритму Чанди-Мизра , но содержит дополнительную
информацию которая позволяет таблицам только частично перевычисляться
после отказа или восстановления канала. Представление алгоритма в этой части
придерживается Лампорта [Lam82]. Алгоритм основан на следующих предположениях.

Nl. Узлы знают размер сети (N).

N2. Каналы удовлетворяют
дисциплине FIFO.

N3. Узлы уведомляют об отказах и
восстановлениях смежных к ним каналов.

N4. Цена пути – количество
каналов в пути.

Алгоритм может управлять отказами и восстановлениями или
добавлениями каналов, но положим что узел уведомляет когда смежный с ним канал
отказывает или восстанавливается. Отказ и восстановление узлов не
рассматривается: на самом деле отказ  узла можно рассматриваться его соседями
как отказ соединяющего канала. Алгоритм содержит в каждом  узле  u
таблицу Nbu [v], дающую для каждого пункт назначения v 
соседа  u через которого u пересылает пакеты для v. Требования
алгоритмов следующие:

Rl. Если топология сети остается постоянной после конечного
числа топологических изменений , тогда алгоритм завершается после конечного
числа шагов.

R2. Когда  алгоритм завершает свою работу таблицы Nbu[v]
удовлетворяют

(a)   если v = u
то Nbu[v] = local ;

(b)  если путь из u
в v ¹ u существует
то Nbu[v] = w, где  w первый сосед  u в
кротчайшем пути из u в v,

(c)    если нет пути
из u в v тогда Nbu[v] = udef.

 

4.3.1 Описание алгоритма

Алгоритм Таджибнаписа Netchange дан как  алгоритмы  4.8 и
4.9. Шаги алгоритма будут сначала объяснены неформально, и, впоследствии
правильность алгоритма будет доказана формально. Ради ясности моделирование
топологических изменений упрощено по сравнению с [Lam82],  примем, что
уведомление об изменении обрабатывается  одновременно двумя узлами
задействованными изменениями. Это обозначено в Подразделе 4.3.3, как 
асинхронная обработка.

Выбор соседа через которого пакеты для v будут
посылаться основан на оценке расстояния от каждого узла до v.
Предпочитаемый сосед всегда сосед с минимальной оценкой расстояния. Узел u
содержит оценку d(u, v) в Du[v] и оценки d(w, v) в 
ndisu[w, v] для каждого соседа u. Оценка  Du[v]
вычисляется из оценок  ndisu[w, v], и оценки  ndisu[w,v]
получены посредством коммуникаций с соседями.

Вычисление оценок  Du[v]
происходит следующим образом. Если u = v тогда d(u, v) = 0 таким
образом Du[v] становится  0 в этом случае. Если u¹ v, кротчайший путь от u в v
(если такой путь существует) состоит из канала из u до  сосед,
присоединенного к  кратчайшему пути из сосед до v, и следовательно        
                                        d(u, v) = 1 + min d(w, v).

                                                                  
wÎ Neigh u

Исходя из этого равенства, узел u ¹v оценивает d(u, v)
применением этой формулы к оценочным значениям d(w, v), найденным
в таблицах ndisu[w, v]. Так как всего N узлов, путь  с
минимальным количеством шагов имеет длину не более чем  N—1 . Узел может
подозревать что такой путь не существует если   оцененное расстояние равно  N
или больше; значение  N используется для этой цели.

var       Neighu    : множество
узлов ;  (* Соседи  u *)

                  Du     : массив   0.. N
;        (* Du[v] – оценки d(u, v) *)

                 Nbu    : массив узлов
;       (* Nbu[v]- предпочтительный  сосед для v *)

                  ndisu : массив  0.. N
;         (*ndisu[w, v] – оценки d(w. v) *)

Инициализация:

       begin forall w Π Neighu , v Î V do ndisu[w, v] := N
,

                  forall v Π V do

                             begin Du[v]
:= N ;

                                        Nbu[v]
:= udef

                              end ;

                   Du[u]:= 0 ; Nbu[u]
:= local ;

                   forall w Î Neighu do
послать < mydist, u, 0> к w

         end

процедура Recompute (v):

        begin if v = u

                 then begin Du[v]:=
0 ; Nbu[v] := local end

                 else begin (* оценка расстояния до v
*)

                           d := 1 + min{ ndisu[w,
v] : w Î Neighu}
;

                           if d < N
then

                                begin Du[v]
:= d ;

                                          Nbu[v]
:= w with 1 + ndisu[w, v] = d

                                end

                        else begin Du[v]
:= N ; Nbu[v] := udef end

                 end;

                 if Du[v]
изменилась then

                        forall x Π Neighu do
послать < mydist, v, Du[v]> к x

          end

Алгоритм 4.8 Алгоритм
Netchange (часть I, для узла u).

Алгоритм требует чтобы узел
имел оценки расстояний до v своих соседей. Их они получают от 
этих узлов послав им  сообщение <mydist,.,.> следующим образом. Если узел
u вычисляет значение  d как оценку своего расстояния до v (Du[v]
= d), то эта информация посылается всем соседям в сообщении < mydist ,v,d>.
На получение сообщения <mydist, v, d>  от соседа w, u
означивает ndisu[w, v] значением d. В результате изменения  
ndisu[w, v] оценка  u  расстояния d(u, v) может
измениться и  следовательно оценка перевычисляется каждый раз при изменении
таблицы ndisu . Если оценка на самом деле изменилась то, на d’
например, происходит соединение с соседями используя сообщение <mydist,
v, d’>.

Алгоритм реагирует на отказы
и восстановления  каналов изменением локальных таблиц, и посылая сообщение
<mydist, ., .> если оценка расстояния изменилась. Мы предположим что
уведомление  которое  узлы получают о падении или подъеме  канала 
(предположение N3)  представлено в виде сообщений < fail,. > и
<repair, . >. Канал между узлами u1 и u2 
смоделирован двумя очередями, Q u1 u2  для
сообщений от u1 к u1 и Q u2 u1
для сообщений из  u2 в u1. Когда канал
отказывает эти очереди удаляются из конфигурации (фактически вызывается потеря
всех сообщений в обоих очередях) и узлы на обоих концах канала получают сообщение
< fail, . > . Если канал между u1 и u1
отказывает, u1 получает сообщение < fail, u2
> и u2 получает сообщение < fail, u1
> . Когда  канал  восстанавливается (или добавляется новый канал в сети)
две пустые очереди добавляются в конфигурацию и два узлы соединяются через 
канал получая сообщение < repair, . > . Если  канал между u1
и u2 поднялся  u1 получает сообщение<
repair, u2 >  и u2 получает
сообщение < repair, u1 > .

Обработка сообщения <mydist,v,d>  от
соседа w:

             { <mydist,v,d> через
очередь Qwv}

             begin  получить <mydist,v,d>
от w;

                         ndisu[w,v] := d
; Recompute (v)

               end

Произошел отказ  канала uw:

             begin получить < fail, w>
; Neighu := Neighu \ {w} ,

                        forall v Î V do Recompute (v)

              end

Произошло восстановление  канала  uw:

            begin получить < repair,
w> , Neighu := Neighu È {w} ;

                           forall v Î V do

                                   begin ndisu[w,
v] := N;

                                             послать <
mydist, v, Du{[v]> to w

                                   end

              end

Алгоритм 4.9
АЛГОРИТМ  NETCHANGE (часть 2, для узла и).

 

Реакция алгоритма на отказы и восстановления выглядит
следующим образом. Когда канал между u и w отказывает, w 
удаляется из Neighu и наоборот. Оценка расстояния
перевычисляется для каждого пункта назначения  и, конечно, рассылается всем
существующим соседям если оно изменилось. Это случай если лучший маршрут был
через отказавший канал и нет другого соседа w’ с ndisu[w’,
v]= ndisu[w, v]. Когда канал  восстановлен(или добавлен новый
канал) то  w добавляется в Neighu, но  u  имеет
теперь неоцененное расстояние d(w, v) (и наоборот). Новый сосед w немедленно
информирует относительно  Du[v] для всех пунктов назначения  v
(посылая сообщения<mydist,v, Du[v]> ). До тех
пор пока u получает подобное сообщения от w, u использует N
как оценку для d(w,v), т.е., он устанавливает ndisu[w, v]
в N.

 

 

P(u, w, V)º

                  up(u, w) Û w Î
Neighu                                  (1)

              Ù
up(u, w) Ù  Qwu
содержит сообщение  <mydist,v,d> Þ

                     последнее такое сообщение
удовлетворят d = Du[v]    (2)

             Ù 
up(u, w) Ù Qwu
не содержит сообщение <mydist,v,d> Þ

                    ndisu[w, v] =Dw
[v]                                       (3)

        L(u, v) º

                     u = v Þ (Du[v] = 0 Ù Nbu[v] = local)            (4)

                Ù 
(u ¹ v)Ù $w
Î Neighu :
ndisu[w, v] < N – 1)Þ

                     ( Du[v] = 1 +  min ndisu[w,
v] = 1 + ndisu[Nbu[v], v])    (5)

                                           w Î Neigh u

                Ù
(u ¹ v Ù "w
Î Neighu :
ndisu[w, v]³
N—1) Þ

                           (Du[v] = N
Ù Nbu[v] = udef)                             
(6)

 

Рисунок 4.10
Инварианты P(u, w, v) и L(u, v).

 

Инварианты алгоритма Netchange. Мы докажем что
утверждения являются инвариантами; утверждения даны на Рисунке 4.10.
Утверждение P(u, w, v) констатирует что если u закончил обработку
сообщения <mydist, v, .>  от w то оценка  u
расстояния d(w,v) эквивалентна оценке  w расстояния  d(w, v). Пусть 
предикат  up(u, w) истинен тогда и только тогда когда  (двунаправленный)
канал между u и w существует и действует. Утверждение L(u, v)
констатирует что оценка  u расстояния d(u, v) всегда согласована
с локальными данными u, и Nbu[v] таким образом
означен.

Выполнение алгоритма заканчивается когда нет больше
сообщений в любом канале. Эти конфигурации не терминальны для всей системы так
как вычисления в системе могут продолжится позже, начавшись отказом или
восстановлением канала (на которые алгоритм должен среагировать). Мы пошлем 
сообщение конфигурационной стабильности, и определим предикат stable как

                     stable = "u, w : up(u, w) Þ Qwu не содержит сообщений
<mydist,., .>.

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

(1) Получение
сообщения <mydist, .,.> . Первое выполнение результирующего
кодового фрагмента, как принято, выполняется автоматически и рассматривается
отдельным переходом. Обратите внимание что в данном переходе принимается
сообщение и возможно множество сообщений отправляется

 (2) Отказ
канала и обработка сообщения < fail. . > узлами на обоих концах
канала.

(3)
Восстановление канала и обработка сообщения <repair. . >  двумя
соединенными  узлами.

 

Лемма 4.14 Для всех  uo, wo,
и vo, P(uo, wo, vo) ––  инвариант.

 

Доказательство. Изначально, т.e., после выполнения
инициализационной процедуры  каждым узлом, (1) содержится предположением. Если
изначально мы имеем Øup(uo,
wo), (2) и (3) тривиально содержатся. Если изначально мы имеем up(uo,
wo), тогда ndisuo[wo, vo]
= N. Если wo = vo то Dwo[wo]
= 0 но сообщение < mydist, vo, 0>  в Qw0u0,
таким образом (2) и (3)  истинны. Если wo ¹ vo то Dw0[vo]=N
и нет сообщений в очереди,  что также говорит что (2) и (3) содержаться. Мы
рассмотрим три типа констатированных переходов упомянутых выше.

Тип
(1). Предположим что u получает сообщение  <mydist,v,d>
от w. Следовательно нет топологических изменений и нет изменений в
множестве Neigh , следовательно (1) остается истинно. Если v¹vo  то это сообщение не
меняет ничего в P(uo, wo, vo). Если v
= vo, u =uo, и w=wo
значение ndisu,[wo, vo] может изменится.
Однако, если сообщение < mydist, vo, .> остается
в канале значение этого сообщения продолжает удовлетворять (2), так как (2) в сохранности
то и (3) также потому что посылка ложна. Если полученное  сообщение было
последним этого типа в канале то d = Dw0[vo] по (2),  которое
подразумевает что заключение (3) становится истинным и (3) в сохранности.
Посылка (2) становится ложной, таким образом (2) в сохранности. Если v =
vo, u = wo (и uo сосед u) 
заключение  (2) или (3) может быть ложно если значение Dw0[vo]
изменилось в следствие выполнения Recompute(v) в wo. В
этом случае, однако,  сообщение < mydist, vo, .
> с новым значением  посылается к uo, которое
подразумевает что посылка (3) нарушена, и заключение (2) становится истинным,
таким образом  (2) и (3) сохранены. Это происходит и в случае когда сообщение
< mydist, vo, . > добавляется в Qw0u0,
и это всегда удовлетворяет d = Dw0[vo]. Если
v = vo и u¹uo,
wo ничего не изменяет в P(uo, wo, vo).

Тип (2).
Предположим что канал  uw отказал. Если u = uo и
w = wo этот отказ нарушил посылку (2) и (3) таким
образом эти правила сохранены. (1) в безопасности потому что wo
удалился из Neighu0 и обратно. Нечто произойдет если u = wo
и w = uo. Если u = wo но w¹ uo заключение (2) или
(3) может быть нарушено так как значение Dw0 [vo]
изменилось. В этом случае пересылка сообщения < mydist, vo,
. > узлом  wo опять нарушит посылку (3) и сделает
заключение  (2) истинным, следовательно (2) и (3) в безопасности. Во всех
других случаях нет изменений в P(uo, wo, vo).

Тип (3).
Предположим добавление канала uw. Если u = uo и
w = wo то up(vo,wo)
истинно, но добавлением wo в Neighu0 (и
обратно) это защищает(1). Посылка < mydist, vo, Dw0
[vo]> узлом wo делает заключение (2) истинным
и посылку (3) ложной, таким образом P(uo, wo, vo)
обезопасен. Во всех других случаях нет изменений в P(uo, wo,
vo).

ˆЛемма 4.15 Для каждого  uq и vo,
L(uo, vo)­ –инвариант.

 

Доказательство. Изначально Du0[uo] = 0
и Nbu[uo] = local. Для vo ¹uo , изначально ndisu[w,
vo] = N для всех w Î
Neighu, и Du0[vo] = N и Nbu0[vo]
= udef.

Тип (1).
Положим что u получил сообщение  < mydist, v,d> от w.
Если u¹ uo
или v¹ vo
нет переменных упомянутых изменениях L(uo, vo) .
Если u = uo и v = vo значение  ndisu[w,
vo] меняется, но Du0 [vo] и Nbu0[vo]
перевычисляется точно так как удовлетворяется L(vo, vo).

Тип (2).
Положим что канал uw отказал. Если u = uo или w
= uo то Neighu0 изменился, но опять Du0[vo]
и Nbu0[vo] перевычисляются точно так как  удовлетворяется
L(uo, vo).

Тип (3).
Положим что добавлен  канал uw . Если u = uo то
изменилсяNeighu0  добавлением w, но так  как u устанавливает
ndisu0[w, vo] в N это сохраняет L(uo,
vo).

4.3.2
Корректность алгоритма Netchange

Должны быть доказаны два требования корректности.

Теорема 4.16 Когда достигнута стабильная
конфигурация, таблицы Nbu[v] удовлетворяют :

(1) если u
= v  то Nbu[v] = local;

(2) если 
путь от u до v¹ u
существует то Nbu[v] = w, где  w первый сосед  u на  кратчайшем пути
от u до v;

(3) если
нет путь от u до v не существует то Nbu[v] = udef.

 

Доказательство. Когда алгоритм прекращает работу,
предикат  stable добавляется к  P(u,w,v) для  всех u, v, и
w, и это подразумевает что для всех u, v, и w

                                up(u, w) Þ ndisu[w, v] = Dw[v].               
(4.2)

Применив также L(u, v) для всех u и v
мы получим

               ì0                                  
если  u ¹ v

Du [v] = í 
1+ min Dw[v]             если  u¹ v Ù$w Î
Neighu : Dw[v] < N -1

               îN     w ÎNeigh u                 если  u¹v  Ù"w Î
Neighu : Dw[v]³
N -1

                                                                                                                        (4.3)

которого достаточно для доказательства что Du[v]
= d(u, v) если u и v в некотором связном компоненте сети,
и Du[v] = N  если u и v в различных
связных компонентах.

Во-первых покажем индукцией по d{u, v) что если u
и v в некотором связном компоненте то Du[v]£ d(u, v).

Случай d(u, v) = 0: подразумевает  u = v
и следовательно Du[v] = 0.

Случай
d(u, v) = k +1: это подразумевает что существует узел w Î Neighu с d(w, v)
= k.      По индукции Du[v] £ k,  которое по (4.3) подразумевает что Du[v]
£ k + 1.

Теперь покажем индуктивно по Du[v] что
если Du[v] < N то существует путь между u и v
и d(u, v) £ Du[v].

Случай
Du[v] = 0: Формула (4.3) подразумевает что Du[v]
= 0 только для u = v, что дает пустой путь между u и v,
и d(u, v) = 0.

Случай
Du[v] = k +1 < N : Формула (4.3) подразумевает что
существует  узел w Î
Neighu с Dw[v] = k. По индукции существует
путь между  w и v и d(w, v) £ k, что подразумевает существование пути между u
и v и d(u, v) < k+ 1.

Следовательно что если u и v в некотором
связном компоненте то Du[v] = d(u, v), иначе Du[v]
= N. Это, Формула (4.2), и "u,v
: L(u, v)  и доказывает теорему о Nbu[v].                        
[]

Докажем что стабильная ситуация в конечном счете достигается
если топологические изменения прекращаются, норм-функция в отношении stable
определена. Определим, для конфигурации алгоритма g,

                   ti =   (число сообщений
<mydist, .,i>) +

                            (число упорядоченных пар u, v
таких что Du[v] = i)

и функцию f 

                        f(g) = (to, t1,…, tN)

 

f(g)   кортеж
из  (N + l) натуральных чисел, в некотором лексиграфическом порядке
(обозначенном £l)
. напомним что  (N, £l)
хорошо-обоснованное множество (Упражнение 2.5).

 

Лемма 4.17 Обработка сообщения  <
mydist,.,. > уменьшает f.

 

Доказательство. Пусть узел u с Du[v]
= d1  получил сообщение < mydist, v, d2>
, и после перевычислил новое значение Du[v]  – d.
Алгоритм подразумевает что d < di + 1.

Случай
d < d1: Пусть d = d1 + 1 что
подразумевает что td2 уменьшилось на 1 (и td1
следовательно), и только td с d > d1
увеличилось. Это подразумевает что значение f  уменьшилось.

Случай
d = d1: Не новое сообщение < mydist, .,
.> посланное  u, и влияет только на f  так что  td2
уменьшилось на 1, т.о. значение  f  уменьшилось.

Случай
d > d1: Пусть td1  уменьшилось
на 1 (и td2 следовательно), и только td с d
> d1 увеличилось. Это подразумевает что значение f
уменьшилось.

[]

Теорема 4.18 Если  топология  сети остается
неизменной после конечного числа топологических изменений, то  алгоритм
достигнет стабильной конфигурации за конечное число шагов.

 

Доказательство. Если  сетевая топология остается
постоянной  только обрабатывая  сообщения  <mydist,.,.>которые
имеют место, и, по предыдущей лемме, значение f уменьшается с каждым
таким переходом. Это следует из хорошей обоснованности области  f  в
которой может быть только конечное число таких переходов; следовательно
алгоритм достигает стабильной конфигурации после конечного числа шагов. []

 

4.3.3
Обсуждение алгоритма

Формальные результаты правильности алгоритма, гарантирующие
сходимость для исправления таблиц за конечное время после последнего
топологического изменения, не очень хорошо показывают фактическое поведение
алгоритма. Предикат stablе может быть ложным практически долгое время (а
именно, если топологические изменения часты) и когда stablе ложен, ничто
не известно о таблицы маршрутизации. Они могут содержать циклы или даже давать
ошибочную информацию относительно достижимости узла назначения. Алгоритм поэтому
может только применятся, где топологические изменения настолько редки, что
время  сходимости алгоритма является малым по сравнению с средним временем
между  топологических изменений. Тем более , потому что stablе  –
глобальное свойство, и устойчивые конфигурации алгоритма неразличимы от
неустойчивых для узлов. Это означает, что узел никогда не знает, отражают ли
таблицы маршрутизации правильно топологию сети, и не может отсрочить отправления 
пакетов  данных , пока устойчивая конфигурация не достигнута.

 

Асинхронная обработка уведомлений. Было  этой части
предположили что уведомления о топологических изменениях  обрабатываются
автоматически вместе с именением в единой транзакции. Обработка происходит на
обоих сторонах удаленного или добавленного канал одновременно. Лампорт [Lam82]
выполнил анализ мелких деталей и учел задержки  в обработке этих уведомлений.
Коммуникационный  канал от w до u  смоделирован объединением трех
очередей.

(1) OQwu , 
выходная очередь  w,

(2) TQwu ,  очередь
сообщений  (и пакетов данных)  передаваемая

(3) IQwu ,  
входная очередь u.

При нормальном функционировании  канала, w посылает
сообщение к u добавлением его в OQwu, сообщения
двигаются от OQwu к TQwu и от TQwu
к IQwu, и u получает их удаляя из IQwu.
Когда  канал отказывает  сообщения в TQwu  выбрасываются и
сообщения в OQwu соответственно выбрасываются  раньше чем добавились
к TQwu. Сообщение < fail, w>  становится
в конец IQwu, и когда нормальное функционирование восстановилось 
сообщение <repair,w>  также становится в конец IQwu.
предикаты P(u, w, v)  принимают слегка более  сложную форму но алгоритм
остается тот же самый.

Маршрутизация по кротчайшему пути. Возможно означить
вес каждого канала и модифицировать алгоритм так чтобы  вычислять кратчайший
путь вместо пути с  минимальным количеством шагов. Процедура Recompute
алгоритма Netchange использовать вес  канала uw в  вычислении оценки
длины кратчайший путь через w если константу 1 заменить на wuw.
Константа N  в алгоритме должна быть заменена верхней границей диаметра 
сети.

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

Даже возможно расширить алгоритм для работы с изменяющимися
весами каналов; реакция узла u на изменение веса канала – перевычисление
Du[v] для v. Алгоритм был бы практическим, однако,
только в ситуации когда  среднее время изменений стоимостей каналов больше
времени сходимости что не реально. В этих ситуациях  должна алгоритм должен
предпочесть гарантию свободы от циклов в течение сходимости, на пример алгоритм
Мерлина-Сигалла.

4.4
Маршрутизация с Компактными Таблицами маршрутизации

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

Стратегию уменьшения таблицы в каждом из трех механизмов
маршрутизации, обсуждаемых в этой части, просто объяснить следующим образом.
Если  таблицы маршрутизации узла хранят выходящий канал для  каждого пункта
назначения отдельно, таблица маршрутизации имеет длину N; следовательно 
таблицы требуют W(N) бит,
не важно как  компактно выходящий канал закодирован для каждого пункта
назначения. Теперь рассмотрим перестройку таблицы: таблица содержит для каждого
канала узла ссылку говорящую какие пункты назначения должны быть
смаршрутизированны через этот канал; смотри Рисунок 4.11. Таблица теперь имеет
"длину"  deg для  узел с deg каналами; теперь
компактность зависит от того как компактно множество пунктов назначения для
каждого канала может быть представлено.

Рисунок 4.11
Уменьшение размера таблицы маршрутизации.

4.4.1 Схема
разметки деревьев

Первый метод  компактной маршрутизации был предложен Санторо
и Кхатибом [SK85]. Метод основан на пометке узлов целыми от 0 до N— I, 
таким образом чтобы множество пунктов назначения для каждого канала было
интервалом. Пусть  ZN  обозначает  множество {0,
1,…, N- 1}. В этой части все арифметические операции по модулю  N,
т.e., (N— 1) + 1º 0.

 

Определение 4.19 Циклический интервал [a, b)
в ZN  – множество целых определенное как

 

 

                       ì
{a, a +1,…, b -1}                  если a<b

            [a,b)= í {0,. . ., b- 1, a,…, N-1}          если  a³b

                       î

Заметим что  [a, a) = ZN, и для a ¹ b дополнение [a, b) – [b,
a). Циклический интервал [a, b) называется линейным если
a < b.

 

Теорема 4.20  Узлы дерева T могут быть
пронумерованы таким образом что для каждого выходящего канала  каждого узла
множество пунктов назначения которые маршрутизируются через данный канал есть
циклический интервал.

 

Доказательство. Возьмем произвольный узел vо
за корень дерева и для каждого w пусть обозначим за T[w]
поддерево  T с корнем в w. Возможно перенумеровать  узлы таким образом
чтобы для каждого  w  числа для означивания узлов в  T[w] составляли
линейный интервал, на пример префиксным обходом  дерева как на Рисунке 4.12.  В
этом порядке, w – первый узел дерева T[w] который посетится и
после w все узлы T[w] посетятся перед узлами не входящими в T[w];
следовательно  узлы в T[w] перенумерованы линейным интервалом [lw,
lw +|T{w]|) (1w метка w).

Через [aw,
bw) обозначим интервал чисел означивающие узлы в T[w]. Сосед 
w – один из двух сыновей или отец w. Узел w передает к
сыну u  пакеты с пунктом назначения в  T[u], т.е., узлы с числами
в  [au, bu). Узел w передает  своему
отцу пакеты с пунктами назначения не в  T[w], т.е., узлы с номерами в
 ZN \[aw,bw) = [bw,aw).         
[]

Рисунок 4.12 Префиксный
обход дерева

Циклический интервал может быть представлен использование 
только 2 log N  бит дающих начальный и конечный пункт. Так ка в этом
приложении объединение разъединенных интервалов в объединении ZN 
должно хранится, достаточно logN бит на интервал.
Хранится только начальная точка интервала для каждого канала; конечная точка
эквивалентна начальной точке следующего интервала в том же узле. Начальная
точка интервала приписанного каналу  uw в узле u дается как

                    ì        
lw                       если w сын u,

         auw
=  í

                    î     
lu+|T[u]|              если  w отец u

Положим что каналы узла u
со степенью degu помечены a1,…,
adeg u , где a1 < ,…,< adeg u ,  передающая процедура
дана в Алгоритме 4.13. Метки  каналов отображают ZN в
сегменты degu  , каждый соответствует одному каналу; см.
Рисунок 4.14. Заметим что существует (не более чем) один интервал который не
линейный. Если метка отсортированы в узле, соответствующая метка находится за
О(log degu)  шагов используя бинарный поиск. Индекс  i
вычисляется по модулю degu, т.e., adeg u+1  == a1.

(* пакет с адресом  d был получен в  узле u *)

if d = lu

       then доставить пакет локально

       else begin   выбрать ai, т.ч.  d Î [ai,
ai+1) ;

                           послать пакет через канал с
меткой ai

       end

Алгоритм 4.13 Интервальная
передача (для узла  u).

 

Рисунок 4.14 Часть  ZN
в узле.

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

Сравним длины  путей выбранное этой схемой с оптимальными
путями, пусть dT(u, v) обозначает расстояние от u до v
в T и dG(u, v)  расстояние от u до v в G.
Пусть DG обозначает диаметр G, определенный как
максимум для любых u и v из dG(u, v).

 

Лемма 4.21 Нет общего ограничения пропорции между 
dT(u, v) и dG(u, v).Это имеет силу только в специальном
случае измерения переходами путей.

 

Доказательство. Выберем G как кольцо из N
узлов, и заметим что дерево охвата G  получается удалением одного канала,
скажем xy, из G. Теперь dG(x, y) = 1 и dT(x,
y) = N-1,таким образом пропорция  N—1. Пропорция может быть
гораздо больше выбором большего кольца.                                      
[]

Следующая Лемма полагается на симметричность стоимостей
каналов, т.е., это значит что wuw = wwu
.Это подразумевает что dG(u, v) = dG(v, u)
для всех  u и v.

 

Лемма 4.22 T может быть выбрано таким образом
чтобы для всех u и v, dT(u, v) £
2G.

 

Доказательство. Выберем T  как оптимальное
дерево стока для узла wo (как в Теореме 4.2). Тогда

                            dT(u, v) £ dT(u, wo)
+ dT(wo,v)

                                         = dT(u,
wo)+ dT(v, wo)  по симметричности  w

                                          = dG(u,
wo)+ dG(v, wo) по симметричности T

                                          = DG+DG                               
по определению DG

[]

 

В заключении , a путь выбранный одной схемой может быть
плохом если сравнить с оптимальным  путём между этими же двумя узлами (Лемма
4.21), но если выбрано подходящее дерево охвата, он в s не более чем два раза
хуже пути между двумя другими узлами в системе(Лемма 4.22).

Схема разметки деревьев имеет следующие недостатки.

(1)  Каналы не
принадлежащие T не используются

(2) Трафик сосредоточен в  дереве,(может произойти
перегрузка).

(3)Каждый отказ канала делит сеть.

4.4.2
Интервальная маршрутизация

Ван Ливен и Тэн [LT87] расширили схему разметки деревьев до
сетей не являющихся деревьями таким образом что каждый канал используется для
передачи пакета.

Определение 4.23 Схема разметки деревьев  (ILS)для
сети это

(1) обозначение различными метками из ZN 
узлов сети, и,

(2) Для
каждого узла, обозначение различными метками  из ZN 
каналов данного узла

 

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

 

Определение 4.24 Схема интервальной разметки
применим  если все пакеты передаются этим путем которым достигнут своего пункта
назначения.

 

Можно показать что применимая схема интервальной разметки 
существует для каждой связной сети G (Теорема 4.25); для произвольной связной
сети, однако, схема обычно не очень эффективна. Оптимальность путей выбранных
схемой интервальной маршрутизации будет изучена после существующего доказательства.

Теорема 4.25 Для каждой связной сети G применимая
схема интервальной разметки  существует.

 

Доказательство. Схему применимой интервальной пометка
построим расширением схемы разметки деревьев  Санторо и Кхатиба, применив к
дереву охвата сети T . В данном дереве охвата  ребро ветви – ребро
которое не принадлежит дереву охвата. Более того, v  потомок  u
если только u Î T[v].
Основная проблема как означить метки ребер ветвей (ребра дерева будут помечены
схемой разметки деревьев),  дерево охвата выбирается таким образом чтобы все
ребра ветвей приняли ограниченную форму

Лемма 4.26 Существует  дерево охвата такое что
между узлом потомком этого узла.

 

Доказательство. Каждое дерево охвата полученное
обходом в глубину через сеть имеет это свойство; смотри [Tar72] и Часть
6.4.             []

В продолжении, пусть  T  будет зафиксированное дерево охвата
поиска в глубину в G.

Определение 4.27 Поиск в глубину ILS для  G
(в отношении к  T)  – схема разметки для которой выполняются следующие правила.

(1) Метки узлов означены префиксным обходом в T, т.е.,
узлы в поддереве T[w] помечены числами из [lw, ,lw+|T[w]|).
Обозначим  kw = lw+ |T[w]|.

(2) Метку ребра  uw в узле u обозначим auw.

(a)  Если
uw ребро ветви то auw
= lw

(b)  Если
w сын  u (в T) то auw
= lw

(c)  Если
w отец u то  auw
= ku  если ku ¹ N и u имеет ветвь к корню. (В последней
ситуации, ребро ветви помечаем  0 в u по правилу (a),таким образом
означивание метки  ku  нарушило бы требование что все метки
различны. Метки считаются по модулю N, т.е.  N º0.)

(d)  Если
w отец u, u имеет ветвь к корню, и  ku º N, тогда  auw = lw.

Все примеры поиска в глубину ILS даны на Рисунке 4.15.
Заметим что все ребра ветвей помечены по правилу (2a), ребра к отцам узлов 4,
8, и 10 помечены  по правилу (2c), и ребро к отцу узла 9 помечено по правилу
(2d).

Теперь покажем верность схемы обхода в глубину ILS . Заметим
что vÎT[u] Û lv Î [lu, ku).
Следующие три  леммы относятся к ситуации когда узел u передает пакет с
пунктом назначения v к узлу w (соседу  u) используя
Алгоритм 4.13. Это подразумевает что lv Î [auw,
a) для некоторой метки a в u, и что нет метки a’¹auw  в узле u такой
что a’ Î
[auw,, lv).

Рисунок 4.15
Интервальная разметка поиском в глубину.

 

Лемма 4.28 Если lu > lv
то lw < Iu

 

Доказательство. Во-первых, рассмотрим случай auw £ lv. Узел w  не сын u потому
что в этом случае auw
= lw > lu > lv .Если  uw
ветвь то также lw = auw
< lv < lu. Если w  отец  u
то lw < lu выполняется в любом случае. Во-вторых,
рассмотрим случай когда auw  –
наибольшая метка ребра в u, и нет метки a’
£ lv
(т.е., lv – нижняя граница нелинейного интервала). В этом
случае ребро к отцу u не помечено 0, но имеет метку ku
(потому что 0£ lv,
и нет метки a’ £ lv). Метка ku
– наибольшая метка в данном случае; ребро к сыну или ветви вниз w’ имеет
auw’ = lw’
< ku, и ветвь к предком w’ имеет auw’ = lw’ < lu
Таким образом w – отец u в данном случае, что подразумевает 1w
< lu.                   []

Следующие две  леммы
относятся к случаю когда lu < lv. Мы
выведем что каждый v Î T[u]
или lv > ku, и в последнем случае ku
< N  имеет силу так что ребро к отцу  u помечено  ku.

Рисунок 4.16
МАРШРУТИЗАЦИЯ ПАКЕТОВ ДЛЯ V В СХЕМЕ РАЗМЕТКИ ILS.

Лемма 4.29 Если lu <lv то
lw £ lv.

Доказательство. Во-первых, рассмотрим случай когда v
Î T[u]; пусть w’ 
сын u такой что  vÎT[w’].
Мы имеем auw’ = lw’
£ lv
и это подразумевает что auw’
£auw£lv < kw’.
Мы вывели что w не является отцом u, следовательно 1w
= auw, что подразумевает
lw < lv.

Во-вторых, рассмотрим  случай когда lv ³ ku. В этом  случае w
отец u, это можно показать следующим образом. Ребро к отцу помечено ku,
и ku £ lv.
Ребро к сыну w’  узла u помечено 1w’ < ku ,
ребро к ветви вниз w’ помечено 1w’ <ku,
и ребро ветви вверх w’ помечено 1w’ < lu.
Поэтому w  отец  u, lw < lu < lv.
[]

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

                      fv(u) = (-lca(u,
v), 1u).

 

Лемма 4.30 Если lu < lv
то fv(w) < fv(u).

 

Доказательство. Во-первых рассмотрим случай когда v
ÎT[u], что подразумевает
lca(u, v) = lu. Если w’ сын u
такой  что v Î T[w’],
мы имеем (как в предыдущей Лемме) что 1w’ £ lw < kw’,
следовательно w ÎT[w’],
что подразумевает lca(u, v) ³ lw’ > lu. Таким
образом fv(w) < fv(u).

Во-вторых, рассмотрим случай что 1v > ku.
Как в предыдущей лемме, w отец u, и поэтому vÏT[u], lca(w, v)= lca(u,
v). Но теперь 1w < lu , таким образом
fv(w)< fv(u).                                                    
[]

Может быть показано что каждый пакет достигает пункта
назначения. Поток пакетов для  v показан на Рисунке 4.16. Пусть пакет
для v сгенерирован в узле u. По Лемме 4.28, метка узла 
уменьшается с каждым переходом, до тех пор пока, за конечное число шагов, 
пакет получен узлом w с 1w£lv. Каждый узел к которому  пакет
пересылается после  w также имеет метку £lv 
по лемме 4.29. За конечное число шагов пакет получает  v, потому что с
каждым шагом fv уменьшается или  пакет прибывает в  v, по
Лемме 4.30. Это завершает доказательство  Теоремы 4.25.            []

Эффективность интервальной маршрутизации: общий случай.
Теорема 4.25 говорит что корректная  ILS существует для каждой сети, но не
предполагает ничего о эффективности путей выбранных схемой. Ясно что ILS с
поиском в глубину используется для демонстрации существования схемы для
каждой сети, но что они не обязательно лучшие возможные схемы. На пример, если
схема с обходом в глубину применена к кольцу из  N узлов,  существуют
узлы u и v с d(u, v) == 2, и схема использует  N —
2 переходов для передачи пакета от u к v (Упражнение 4.8).
Существует  ILS для того же кольца что которая пересылает каждый пакет через
путь с минимальным количеством шагов. (Теорема 4.34).

Определение 4.31  ILS  оптимальна  если она
передает все пакеты через оптимальные пути.

ILS общительна  если она передает  пакет от одного узла к
соседу данного узла за один шаг.

 ILS линейна  если интервал для передачи в  каждом ребре
линейный.

 

Мы называли  ILS с минимальным количеством шагов (или
кротчайший путь) если она оптимальна относительно оценки пути мерой 
минимальным количеством шагов (или кратчайший путь, соответственно). Просто
показать что если схема удовлетворяет мере минимального количества шагов то
схема общительна. Также легко проверить что  ILS линейна тогда и только тогда
когда в каждом узле u с lu ¹ 0 существует ребро с пометкой 0, и в  узле с пометкой 0
существует ребро с меткой  0 или 1. Это показывает что для сетей в общем виде
качество методов маршрутизации плохое, но для некоторых классов специальной
сетевой топологии качество схемы очень неплохое. Это делает метод процессорных
сетей с регулярной структурой, которые используются для реализации параллельных
вычислений с виртуальной общей разделяемой памяти.

Не известно точно как, для произвольной сети, лучшие схемы
интервальной  разметки сравниваются с оптимальными алгоритмами маршрутизации.
Некоторые нижние границы длин путей, как подразумевают оптимальные  ILS не всегда
существуют, было дано Ружечкой(Ruzecka).

Рисунок 4.1T
Граф-паук с тремя ногами

 

Теорема 4.32 [Ruz88] Существует сеть G такая что
для каждой верной ILS в G существуют  узлы u  и v такие что пакет
от u к v доставлен только после по крайней мере 3/2DG
переходов.

 

Известно как лучшие схемы ILC с поиском в глубину
сравниваются с общими лучшими схемами ILS для этих же сетей. Упражнение 4.7
дает очень плохую схему ILS с поиском в глубину для сети которая действительно
допускает оптимальную  ILS (по Теореме 4.37), но может существовать  лучшая
схема ILS с поиском в глубину для такой сети.

В ситуациях когда большинство соединений происходят ммежду
соседями, будучи общительными достаточные требования  для ILS. Так можно
показать из  Рисунка 4.15  схема ILS с поиском в глубину  не обязательно
общительна; узел 4 передает пакеты для узла 2 через узел 1.

Это существенно для применимости метода интервальной 
маршрутизации, которым рассматриваются циклические интервалы. Хотя некоторые
сети допустимы, и даже оптимальны, схемы с линейноинтервальной маршрутизации,
не возможно маркировать каждую сеть линейными интервалами. Применимость схемы
линейноинтервальной  разметки была исследована Бэккером, Ван Лиуином, и Таном
[BLT91].

 

Рисунок 4.18
Оптимальная ILS для кольца

 

Теорема 4.33 Существует сеть для которой нет
применимой схемы линейноинтервальной разметки

 

Доказательство. Рассмотрим граф-паук с тремя  ногами
длины 2, как нарисовано на Рисунке 4.17. Наименьшей матка (0) и наибольшей
метка (6) означены два  узла, и так как всего три  ноги, существует(по крайней
мере) одна нога которая не содержит ни меньшую ни большую метку. Пусть x
будет первым узлом отцентра в этой ноге. Узел x передает пакета
адресованные к 0 и 6 в центр, и  единственный линейный интервал который
содержит и  0 и 6  это полное множество ZN .
Следовательно, x также пересылает пакеты для своих соседей через центр,
и эти пакеты никогда не достигнут своих пунктов назначения.             []

Бэккер, Ван Лиуин и Taн полностью описали класс сетей
топологии которых допускают линейные схемы ILS кротчайших путей  и представили
результаты содержащие классы графических топологий которые допускают адаптацию
и линейные схемы ILS с минимальным количеством шагов линейны.

Оптимальность интервальной маршрутизации: специальные
топологии.

Было показано что существуют оптимальные схемы интервальной
разметки для некоторых классов сетей имеющих регулярную структуру. Сети таких
структур используются , например, в реализации параллельных вычислений.

 

Теорема 4.34 [LT87] Существует схема ILS с
минимальным количеством шагов для кольца из  N узлов.

 

Доказательство. Метки
узлов означены от 0 до N — I  по часовой стрелке. Для узла i 
канал по часовой стрелке означен меткой i +1 и канал против часовой
стрелке означен (i+ [N/2]) mod N, см Рисунок 4.18. С этой
схемой разметки узел с меткой i посылает  пакеты для узлов i+1, …,
(i+ [N/2] ) -1 через канал по часовой стрелке и пакеты для  узлов (i
+ [N/2]), . . . , i —1 через канал против часовой стрелке,
что является оптимальным.                           []

Рисунок 4.19
Оптимальная ILS  для  сетки n x n.

Так как  ILS iв  Доказательстве  Теоремы 4.34  оптимальна ,
она общительна; она линейна.

 

Теорема 4.35 [LT87]  Существует схема ILS  с
минимальным количеством шагов для сетки  n x n .

 

Доказательство. Метки узлов означены по рядам  в
возрастающем порядке, т.е.,  i-ый узел в  j-ом ряду помечен (j – l)n + (i –
1). Канал вверх этого узла помечен 0, канал налево этого узла помечен (j
– l)n, канал направо помечен (J – l)n + i, и канал вниз 
помечен  j n, см Рисунок 4.19. Теперь легко проверить что когда узел u
передает пакет к узлу v,

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

Случай 2: если v в ряду меньшем чем u,
тогда  u посылает  пакет через свой канал вниз;

Случай 3: если v в том же ряду  что и u
но левее,  u посылает пакет через свой левый канал; и

Случай 4: если v в том же ряду что и u
но правее, то u посылает пакет через свой канал направо.

Во всех случаях , u посылает  пакет к узлу ближайшему
к  v, что и подразумевает что выбранный путь оптимальный.                                             
[]

Так как  ILS в  Доказательстве  Теоремы 4.35 оптимальна, он
общительна; то схема также линейна.

 

Теорема 4.36 Существует линейная схема ILS с
минимальным количеством шагов для гиперкуба.

 

Теорема 4.37 [FJ88]  Существует схема ILS 
кротчайших путей для непланарных  сетей с произвольными весами каналов.

 

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

(1) Малая пространственная сложность. Таблицы
маршрутизации могут хранится в 0(deg • log N) бит для узла
степенью deg.

(2) Эффективность
вычислений  таблиц маршрутизации. Таблицы маршрутизации для схем ILC c
поиском в глубину могут быть вычислены используя распределенный обход сети в глубину,
который может использовать O(E) сообщений за время 0(N) ; см
Часть 6.4.

(3) Оптимальность.
Метод маршрутизации способен выбирать оптимальный петь в некоторых классах сетей,
см. Теоремы с  4.34 до  4.37.

Эти  преимущества делают метод применимым для  процессорных
сетей с регулярной топологией.  Транспьютеры часто используются для
конструирования таких топологий, маршрутизационные чипы Инмос 104 (смотри
Раздел 1.1.5)  разработаны для  использования  интервальной маршрутизации.

К сожалению, для сетей с произвольной топологией, когда
методы используют схемы ILS с поиском в глубину присутствуют несколько минусов:

(1) Плохая живучесть. Не возможна легкая адаптация
схемы ILS с поиском в глубину при добавлении или удалении узла в сети. Дерево
ILS не может долго удовлетворять требованию по которому ветвь существует только
между узлом и его предком. В результате минимальное изменение топологии сети
может потребовать полного перевычисления  таблиц маршрутизации, включая вычисление
новых адресов (меток) для каждого узла.

(2) Не
оптимальность. Схема ILS поиска в глубину может направлять пакет через пути
длиной W(N), даже в случаях
сетей с малым диаметром; см Упражнение 4.7.

 (* A пакет с адресом  d был получен или создан узлом
u *)

if d = lu

          then обработать пакет локально

        else
begin ai :=
самая ддлинная матка канала  т.что ai
< d ;

                             послать пакет через канал
помеченый  ai

               end

Алгоритм 4.20 Префиксная передача (для узла u).

 

4.4.3
Префиксная маршрутизация

 

Рассмотрев недостатки интервальной  маршрутизации, Бэккер,
Ван Лиуин, и Taн [BLT93] разработали метод маршрутизации в котором таблицы
могут быть вычислены используя произвольное дерево охвата. Использование
неограниченного дерева охвата может увеличить как живучесть так и
эффективность. Если a канал добавлен между двумя существующими узлами то дерево
охвата остается деревом охвата а новый канал будет ветвью. Если новый узел
добавляется вместе с некоторым количеством каналов соединяющих его с
существующими узлами  то дерево охвата расширяется используя  один из каналов и
новый узел. Остальные каналы становятся ветвями. Оптимальность может быть
улучшена выбором дерева охвата малой глубины (как в лемме 4.22.)

Как метки узлов и каналов   в  префиксной маршрутизации 
предпочтительнее использовать строки чем целые числа, используемые в
интервальной маршрутизации. Пусть S 
­– алфавит; в последствии метка будет строкой над S, s  обозначает
пустую строку, и S* множество
строк над S.  Для отбора канала
для  передачи пакета,  алгоритм рассматривает все каналы которые являются префиксами
адреса пункта назначения. Выбирается самая длинная из этих меток, и  выбранный
канал используется для передачи пакета. На пример, предположим что  узел имеет
каналы с метками aabb, abba, aab, aabc, и aa,
и должен переслать  пакет с адресом aabbc. Метки каналов aabb, aab,
и aa  являются префиксами aabbc, и самая длинная  из этих трех
меток aabb, следовательно  узел передаст пакет через канал помеченный aabb.
Алгоритм передачи дан как Алгоритм 4.20. Мы пишем a <b для обозначения что a префикс b.

 

Определение 4.38 Схема префиксной разметки (над S) для  сети G это:

(1) обозначение различными строками из S* узлов  G; и

(2) Для
каждого узла, означивание различными строками каналов данного узла.

 

Алгоритм префиксной маршрутизация предпалагает что схема
префиксной разметки (PLS) дана, и перенаправляет пакеты Алгоритмом 4.20.

Определение 4.39 Схема  префиксной разметки
приемлема если все пакеты в конечном счете достигнут своих пунктов назначения.

 

Теорема 4.40 Для каждой связной сети G  существует
приемлемая схема PLS .

Доказательство. Мы определим класс схем префиксной
разметки и докажем, как и в Теореме 4.25, что схемы в этом классе приемлемы.
Пусть  T обозначает произвольное дерево охвата в G.

 

Определение 4.41 Дерево Т  схемы PLS для G  это
схема префиксной разметки при которой выполняются следующие правила.

(1) Метка корня – s.

(2) Если w сын  u то 1w  расширяет  lu
одним символом; т.е., если u1, …, uk  сын u в T то 1ui
= luai где
 a1, . . . , ak  –  k различных символов
из S.

(3) Если  uw ветвь то  auw  = lw

(4) Если w сын u то auw
= lw.

(5)   Если w отец 
uто auw= s  если  u не имеет ветви к корню: в
этом случае, auw  =
lw

 

В дереве PLS  каждый узел исключая корень имеет канал
помеченный s, и этот  канал
соединяет узел с предком (отцом узла или корнем дерева). Заметим что  для
каждого канала uw, auw
= lw или auw
= s. Для всех u и v,
v  предок у тогда и только тогда когда lv < lu.

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

Лемма 4.42 Для всех узлоа  u
и vтаких что  u ¹ v
существует канал в u помеченный  префиксом lv.

 

Доказательство. Если u не корень T то u
имеет канал помеченный s,
который является префиксом lv. Если u корень тогда v
не является корнем, и v ÎT[u]
. Если w  сын  u такой что vÎT[w] то по построению  auw < lv.         []

Следующие три леммы имеют отношение к ситуации когда узел u
передает пакет для  узла v к  узлу w (соседу  u)
используя  Алгоритм 4.20.

Лемма 4.43 Если u Î T[v] то w предок  u.

 

Доказательство. Если auv == s  то w предок u
как упоминалось выше. Если auw = lw то, так
как auw <lv,
также lw<lv
Это подразумевает что w предок v, и также u.[]

                                                             

Лемма 4.44 Если u предок  v то w предок 
v,  ближе к  v чем u.

Доказательство. Пусть w’ будет сыном  u
таким что  v Î T[w’]
тогда auw’ =lw  не пустой префикс lv.
Так как  auw  самый длинный  префикс (в u)  lv, 
то  auw’< auw < lv, таким
образом w предок  v ниже  u.                   []

Лемма 4.45 Если uÏ T[v], то  w предок  v или dT(w,
v) < dT(u, v).

 

Доказательство. Если auw =s  то w отец  u
или корень; отец u ближе к  v чем u потому что u ÏT[v], и корень – предок v.
Если auw = lw то , так как auw
< lv, w – предок v.                        []

Пусть depth будет обозначать  глубину T, т.е.,
число переходов  в самом длинном  простом пути от корня к листьям. Может быть
показано каждый пакет  с пункт назначения v прибудет в свой пункт
назначения за не более чем 2 – depth переходов. Если пакет создан в
предке v то v достигнется не более чем  depth переходов по
лемме 4.44. Если  пакет создан в поддереве T[v] тогда предок  v достигнется
 за не более чем depth переходов по лемме 4.43, после которых v
достигнется за другие depth переходов по предыдущему замечанию. (По
причине того  что путь содержит только предков источника в этом случае, его
длина ограничена также depth .) Во всех других случаях предок  v  достигнется
в пределах depth переходов по лемме 4.45, после которого v
достигнется  в пределах других depth переходов. (Таким образом, в этом
случае длина пути ограничена 2 depth.) Это завершает  Доказательство 
Теоремы 4.40               

[]

            

Следствие 4.46 Для каждой сети  G с диаметром  DG 
(измеренным в переходах)  существует схема префиксной разметки которая
доставляет все пакеты за не более чем 2DG переходов.

 

Доказательство. Воспользуемся  деревом PLS   что
качается дерева выбранного в Лемме 4.22.   []

Мы включили  обсуждение  схему разметки деревьев с грубым
анализом его пространственных требований. Как и раньше,  depth – глубина
T, и пусть k будет максимальным количеством сыновей дюбого узла T.
Тогдаe самая длинная метка состоит из  depth символов, и  S должен содержать (по крайней мере) k
символов, метка может храниться в depth • log A  бит. Таблица
маршрутизации a узла с deg каналами хронится в  0(deg* depth *
log k) бит.

Несколько другая схема префиксной разметки бала предложена
Бэккером. [BLT93]. Его статья также характеризует класс топологий
который допускает   оптимальные схемы префиксной разметки когда веса
связей могут меняться динамически.

4.5
Иерархическая маршрутизация

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

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

(2) Размер таблицы маршрутизации. В методах 
маршрутизации описываемые в разделах 4.2 и 4.3, таблица содержит ссылку на
каждый узел, и таким образом имеет линейный размер.

(3) Цена табличного поиска. Цена простого табличного
поиска больше для большей таблицы маршрутизации  или для больших адресов.
Полное время табличного поиска для обработки простого сообщения  также зависит
от количества обращений к таблице.

В методе иерархической маршрутизации , сеть разделена на
кластера, каждый кластер есть связное подмножество узлов. Если  источник и
пункт назначения  пакета  в одном кластере, цена передачи сообщения низка,
потому что пакет маршрутизируется внутри кластера, кластер трактуется как
небольшая изолированная сеть. Для метода описанного в разделе 4.5.1, в каждом
кластере зафиксирован простой узел (центр кластера) который может делать
наиболее сложные маршрутизационные решения необходимые для пересылки пакетов в
другие кластера. Таким образом, большие  таблицы маршрутизации и манипуляция
длинными адресами необходима только в центрах. Каждый кластер сам может
разделиться на подкластеры для многоуровневого деления узлов.

Не  необходимо но желательно чтобы каждая коммутация между
кластерами велась через центр; этот тип конструкции имеет такой недостаток  что
весь кластер становится уязвимым на отказ центра. Лентферт [LUST89] описал
метод иерархической маршрутизации в котором все узлы в равной степени могут посылать
сообщения  другим кластерам. Также метод использует только маленькие таблицы,
потому что ссылки на кластеры к которым узел не принадлежит  трактуется как
простой узел. Овербух [ABNLP90] использует парадигму иерархической
маршрутизации для конструирования класса схем маршрутизации которые всегда
балансируют между эффективностью и пространственными требованиями.

4.5.1
Уменьшение количества решений маршрутизации

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

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

Лемма 4.47 Для каждого  s £ N  существует разбиение сети на
кластера C1,…, Cm такие что

(1) каждый кластер – связный подграф,

(2) каждый кластер содержит по крайней мере s узлов, и

(3) каждый кластер имеет радиус не более чем 2s.

 

Доказательство. Пусть D1, …, Dm 
будет максимальная коллекция разделенных связных подграфов таких что каждый  Di
имеет радиус £ s и
содержит по крайней мере s узлов. Каждый узел не принадлежащий  соединен с одним из
подмножеств путем длиной не больше чем s, иначе муть может быть добавлен
как отдельный кластер. Сформируеи кластеры Сi включением
каждого узла не входящего в  в
кластер ближайший к нему. Расширенные кластеры остаются содержат по крайней
мере s узлов каждый, они остаются связными и разделенными, и они имеют
радиус не более чем 2s.               []

Метод маршрутизации означивает цветом каждый пакет, и
предполагается что используется только несколько цветов. Узлы теперь действуют
следующим образом. В зависимости от цвета, пакет или отправляет немедленно по
установленному каналу (соответствующему цвету) или вызывает более сложному
решению. Это подразумевает, что узлы имеют различные протоколы для обработки
пакетов.

 

Теорема 4.48 [LT86] For каждой сети из N узлов
существует метод маршрутизации который требует не более чем 0() решений маршрутизации для
каждого  пакета, и использует три цвета.

 

Доказательство. Предположим что решения (по  Лемме
4.47) даны и заметим что каждый Ci содержит узел ci
такой что  d(v, ci) £ 2s для каждого v Î Ci  потому что  Ci
имеет радиус  не более чем 2s. Пусть  T будет поддеревом минимального
размера из G соединяющее все  ci. Так как T 
минимально то оно содержит не более чем m листьев, следовательно оно
содержит не более чем m-2 узлов разветвлений (узлы степенью большей чем
2); см Упражнение 4.9. Рассмотрим узла  T как центры ( ci),
узлы разветвлений, и узлы пути.

Метод  маршрутизации сначала посылает  пакет к центру ci 
кластера источника (зеленая фаза), затем через  T к центру  cj
кластера пункта назначения  (синяя фаза), и наконец внутри Cj
к  пункту назначения  (красная фаза). Зеленая фаза использует фиксированному
дерево стока для центра каждого кластера, и не решений маршрутизации. Узлы пути
в T  имеют два инцидентных канала, и передают каждый синий пакет через канал
ыв дереве которые не принимают пакет. Узлы ветвлений и центры в T должны
принимать решения маршрутизации. Для красной фазы используется стратегия
кротчайшего пути внутри кластера, которая ограничивает число решений в этой
фазе до 2s. Это ограничивает число решений маршрутизации  до 2m –
2 + 2s, что  не более чем 2N/s – 2+ 2s. Выбор s » дает
ограничение 0().                                                     
[]

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

Теорема 4.49 [LT86) Для каждой сети из  N узелs и
каждого положительного целого числа f £
log N существует метод  маршрутизации  который требует  не более чем O(f
N1/f) решений маршрутизации для каждого  пакета, и использует  2f
+ 1 цветов.

 

Доказательство. Доказательство подобно 
доказательству теоремы 4.48, но  вместо выбора  s» конструирование
применяется рекурсивно к дереву T  (оно кластер размера s).
Дерево – связная сеть, по существу  < 2m узлов потому что узлы пути в
T  только перенаправляют пакеты из одного фиксированного канала в
другой, и может быть игнорирован.

Кластеризация повторяется f  раз. Сеть G имеет
N узлов. Дерево содержит после одного уровня кластеризации не более чем N/s
центров и N/s узлов ветвления, т.е., N.(2/s) необходимых узлов.
Если  дерево полученное после i уровней кластеризации имеет mi
необходимых узлов, тогда дерево полученное после  i +1 уровней
кластеризации имеет не более чем mi/s центров и mi/s
узлов ветвлений, т.е., mi.(2/s) необходимых узлов. Дерево
полученное после f уровней кластеризации  имеет не более чем mf
= N.(2/s)f необходимых узлов.

Каждый уровень кластеризации увеличивает количество цветов
на два, следовательно с f  уровнями кластеризации будут использоваться 
2f+1 цветов. Не более чем 2mf решений необходимо на
самом высоком уровне, и s решений необходимо нв каждом уровне
кластеризации в кластере пункта назначения, отсюда количество решений
маршрутизации 2mf + fs.  Выбирая  s »2N1/f получим mf
= O(1), следовательно число решений маршрутизации ограничено

f s = O(f N1/f).                  
[]

Использование приблизительно logN цветов  приводит к
методу маршрутизации которые требуют O(logN) решений маршрутизации.

Упражнения к
Части 4

Раздел 4.1

Упражнение 4.1 Предположим что таблицы
маршрутизации  обновляются после каждого топологического изменения  таким
образом чтобы они были без циклов даже во время обновлений. Дает ли  это гарантию
что пакеты всегда обработаются даже когда сеть подвергается бесконечному числу
топологических изменений ? Докажите что алгоритм маршрутизации может гарантировать
доставку пакетов при продолжающихся топологических изменениях.

Раздел 4.2

Упражнение 4.2 Студент предложил пренебречь
посылкой сообщения

 < nys, w > из  алгоритма 4.6; он
аргументировал это тем что узел знает своего соседа и не сын в Tw,
если  нет сообщения <ys,w> принятого от этого соседа. Можно ли
модифицировать алгоритм таким образом? Что случиться со сложностью алгоритма?

 

Упражнение 4.3 Докажите что следующее утверждение
является инвариантом алгоритма Чанди-Мизра для вычисления путей до vo
(Алгоритм 4.7).

"u, w :
<mydist,vo,d> Î
Mwu Þ  d(w, vo)
£ d

 Ù" u : d(u, vo) £  Du[vo]

Дайте пример для которого число сообщений экспоненциально
относительно

числа каналов сети.

Раздел 4.3

Упражнение 4.4 Дайте значения всех переменных
терминального состояния алгоритма Netchange когда алгоритм применяется к сети
со следующей топологией:

 

После того как терминальное состояние достигнуто,
добавляется канал между  A и F. Какое сообщение  F пошлет к A когда обработает
уведомление <repair, A> ? Какие сообщения  A пошлет после
получения  сообщений от F?

Раздел 4.4

Упражнение 4.5 Дайте пример демонстрирующий что 
Лемма 4.22 не имеет силу для сетей с ассиметричной стоимостью каналов.

 

Упражнение 4.6 Существует ли  ILS которая 
использует не все каналы для маршрутизации? Она применима? Она оптимальна?

 

Упражнение 4.7 Дайте граф  G и дерево T поиска в
глубину графа G такие что G имеет N = n2  узлов, диаметр G  и
глубина T  –  0(n), и  существуют узлы u и  v такие что пакет от u
к  v доставляется за  N — 1  переходов схемой  ILS поиска
в глубину. (Граф может быть выбран таким образом что G непланарный, что
предполагает (по Теореме 4.37) что  G действительно имеет оптимальную ILS.)

 

Упражнение 4.8 Дайте схему ILS   поиска в глубину
для кольца из N узлов. Найдите узлы  u и v такие что  d(u, v)
= 2,  и схема использует N — 2 переходов для передачи пакета от u к v.

Раздел 4.5

Упражнение 4.9 Докажите что минимальность дерева T
в доказательстве Теоремы 4.48 предполагает что оно имеет не более чем m
листьев. Докажите что любое дерево с m листьями имеет не более чем m
— 2 узлов ветвления.

5
Беступиковая коммутация пакетов

Сообщения (пакеты), путешествующие через сеть с коммутацией
пакетов должны  сохраняться в каждом узле перед тем, отправлением к следующему
узлу на пути к  адресату. Каждый узел сети для этой цели резервирует некоторый
буфер. Поскольку количество буферного места конечно в каждом узле, могут возникнуть
ситуации, когда никакой пакет не может быть послан потому, что все буферы в
следующем узле заняты, как иллюстрируется Рисунком 5.1. Каждый из четырех узлов
имеет буфера B, каждый из которых может содержать точно один пакет. Узел
s послал t B пакетов с адресатом v, и узел v послал
u B пакетов с адресатом s. Все буфера в u и v
теперь заняты, и, следовательно, ни один из пакетов, сохраненных в t и u
не может быть послан к адресату.

Ситуации, когда группа
пакетов никогда не может достигнуть их адресата, потому что они все ждут буфера,
в настоящее время занятого другим пакетом в группе,  называются как тупики с
промежуточным накоплением. (Другие типы тупика будут кратко рассмотрены в
конце этой главы.) Важная проблема в проектировании сетей с пакетной
коммутацией – что делать с тупиками с промежуточным накоплением. В этой главе
мы разберем несколько методов, называемых контроллерами, которые могут
использоваться для того, чтобы избежать возможности тупиков с промежуточным
накоплением,  вводя ограничения на то, когда пакет может быть сгенерирован или
послан. Методы избежания тупиков с промежуточным накоплением найдены в сетевом
уровне модели OSI (Подраздел 1.2.2).

Figure 5.1 Пример
тупика с промежуточным накоплением.

Два вида методов, которые мы рассмотрим, базируются на структурированных
и неструктурированных буферных накопителях.

Методы, использующие структурированные буферные накопители
(Раздел 5.2) идентифицируют для узла и пакета специфический буфер, который
должен быть использован, если пакет генерируется или принимается. Если этот
буфер занят, пакет не может быть принят. В методах, использующих неструктурные
буферные накопители (Раздел 5.3) все буфера равны; метод только предписывает,
может или нет пакет быть принят, но не определяет, в который буфер он должен
быть помещен. Некоторые нотации и определения представляются в Разделе 5.1, и
мы закончим главу обсуждением дальнейших проблем в Разделе 5.4.

5.1 Введение

Как обычно, сеть моделируется графом G = (V, E);
расстояние между узлами измеряется в переходах. Каждая вершина имеет B
буферов для временного хранения пакетов. Множество всех буферов обозначается B, и символы b, c, bu,
и т.д., используются для обозначения буферов.

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

Генерация. Вершина u "создает" новый
пакет p (на самом деле, принимая пакет от протокола более высокого
уровня) и размещает его в пустом буфере в u. Вершина u в таком
случае называется источником пакета p.

Продвижение. Пакет p продвигается от вершины u
в пустой буфер следующей в его маршруте вершины w (маршрут
определяется, используя алгоритмы маршрутизации). В результате передвижения
буфер, прежде занятый p становится пустым. Хотя контроллеры, которые мы определим,
могут запретить передвижения, предполагается, что сеть всегда позволяет это
движение, т.е., если контроллер его не запрещает, то оно применимо.

В системах с синхронной передачей сообщений это перемещение,
как легко видно, является одиночным переходом, как в Определении 2.7. В
системах с асинхронной передачей сообщений, перемещение – не один переход, как
в Определении 2.6, но оно может быть выполнено, например, следующим образом.
Узел u неоднократно передает p к w, но не отбрасывает
пакет из буфера, пока не получено подтверждение. Когда узел w получает
пакет, он решает, примет ли он пакет в одном из буферов. Если примет, пакет
помещается в буфер, и посылается подтверждение u, иначе пакет просто
игнорируется. Конечно, могут быть разработаны более эффективные протоколы для
выполнения таких перемещений, например те, где u не передает p,
пока u не уверен, что w примет p. В любом случае
перемещение состоит из нескольких переходов типа упомянутых в Определении 2.6,
но в целях этой главы оно будет рассматриваться как одиночный шаг.

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

Обозначим через P
множество всех путей, по которым следуют пакеты. Это множество определяется алгоритмами
маршрутизации (см. Главу 4); как это делается, нас здесь не интересует. Пусть k
– количество переходов в самом длинном пути в P.
Это не предполагает, что k равен диаметру G; k может превосходить
диаметр, если алгоритм маршрутизации не выбирает кратчайшие пути, и k
может быть меньше диаметра, если все коммуникации между узлами происходят на
ограниченных дистанциях.

Как видно из примера, данного в начале этой главы, тупики
могут возникнуть, если разрешены произвольные перемещения (исключая тривиальное
ограничение, что u должна иметь пустой буфер, если в u генерируется
пакет и  w должна иметь пустой буфер, если пакет продвигается в w).
Теперь мы определим контроллер как алгоритм, разрешающий или запрещающий
различные движения в сети в соответствии со следующими требованиями.

(1) Выведение пакета (в месте его назначения) всегда
позволяется.

(2) Генерация пакета в вершине, в которой все буферы пустые,
всегда позволяется.

(3) Контроллер использует только локальную информацию, т.е.,
решение, может ли пакет быть принят в вершине u, зависит только от
информации, известной u или содержащейся в пакете.

Второе требование исключает тривиальное решение избежания
заблокированных пакетов (см. Определение 5.2), отказываясь принимать какие-либо
пакеты в сети. Как в Главе 2, пусть Zu  обозначает множество состояний
вершины u, и M – множество возможных сообщений (пакетов).

Определение 5.1 Контроллер для сети G = (V,
E)-набор пар con={Genu, Foru}uÎ V , где Genu Í Zu ´ M и Foru Í Zu ´ M. Если cu Î Zu – состояние u, где
все буферы пусты, то для всех p Î
M, (cu, p) Î
Genu.

Контроллер con позволяет генерацию пакета p в
вершине u, где состояние u – cu, тогда и только
тогда, когда (cu, p) Î
Genu, и позволяет продвижение пакета p из u в w
тогда и только тогда, когда (cw, p) Î Forw. Формальное
определение контроллера не включает условия для выведения пакетов, потому что
выведение пакета (в его месте назначения) всегда позволено. Передвижения сети
под управлением контроллера con – это только те передвижения сети,
которые разрешены con.

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

Определение 5.2 Дана сеть G, контроллер con
для G, и конфигурация g  G, пакет
p (возникающий в конфигурации g)
в тупике, если не существует последовательности передвижений под управлением
con, применимой в g, в
которой p выводится. Конфигурация называется тупиковой, если она
содержит пакеты в тупике.

 

Как показывает пример на Рисунке 5.1, тупиковая ситуация
существует для всех контроллеров. Задача контроллера в том, чтобы не позволить
сети войти в такую конфигурацию. Начальная конфигурация сети – конфигурация,
когда в сети нет пакетов.

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

 

5.2
Структурированные решения

Сейчас мы обсудим класс контроллеров, полагающихся на, так
называемые, буферные графы, представленные Merlin и Schweitzer [MS80a]. Идея
этих буферных графов базируется на наблюдении, что (при отсутствии контроллера)
тупик обусловлен ситуацией циклического ожидания. В ситуации циклического ожидания
есть последовательность p0, …, ps -1
пакетов, таких, что для каждого i, pi хочет передвинуться
в буфер, занятый pi+1 (индексы считаются modulo s).
Циклическое ожидание избегается продвижением пакетов вдоль путей в ациклическом
графе (буферном графе). В Подразделе 5.2.1 будут определены буферные графы и связанный
с ними класс контроллеров, а также представлены два простых примера буферных
графов. В подразделе 5.2.2 будет дана более запутанная конструкция буферного
графа, снова с двумя примерами.

5.2.1 Буферные
Графы

Пусть дана сеть G с множеством буферов B.

Определение 5.4 Буферный граф (для G, B) – направленный граф BG на буферах сети,
т.е., BG = (B, ), так, что

(1) BG – ациклический (не содержит прямых циклов);

(2) Из bc Î
 следует, что b и c – буферы
одной и той же вершины, или буферы двух вершин, соединенных каналом в G; и

(3) для каждого пути P Î
P существует путь в BG, чей образ
(см. ниже)-P.

Второе требование определяет отображение путей в BG
на пути в G; если
b0, b1, …, bs –
путь в BG, то, если u- вершина, в которой располагается буфер bi,
u0, u1,…, us – последовательность
вершин таких, что для каждого i < s либо uiui+1
Î E, либо ui
= ui+1. Путь в G, который получается из этой
последовательности пропусканием последовательных повторений, называется образом
исходного пути b0, b1,…, bs
в BG.

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

Определение 5.5 Пусть p – пакет в вершине u с
пунктом назначения v. Буфер b в u подходит для p, если существует путь в BG из
b в буфер c в v, чей образ – путь, которому p может следовать в G.

Один из таких путей в BG будет называться гарантированным
путем и nb(p, b) обозначает следующий буфер на гарантированном пути. Для
каждого вновь сгенерированного пакета p в u Существует подходящий буфер fb(p) в
u.

Здесь fb и nb – аббревиатура первого буфера
(first buffer) и следующего буфера (next buffer). Заметим, что буфер nb(p,
b) всегда подходит для p. Во всех буферных графов, используемых в этом
разделе, nb(p, b) располагается в вершине, отличной от той, где
располагается b. Использование "внутренних" ребер в BG,
т.е., ребер между двумя буферами одной вершины, обсудим позже.

 

Контроллер буферного графа. Буферный граф BG
может быть использован для разработки беступикового контроллера bgcBG
, записывающий в каждый пакет буфер nb(p, b) и/или состояние вершины,
где располагается p.

Определение 5.6 Контроллер bgcBG
определяется следующим образом.

Генерация пакета p в u позволяется тогда и только тогда,
когда буфер fb(p) свободен. Сгенерированный пакет помещается в этот буфер.

Продвижение пакета p из буфера в u в буфер в w (возможно
u = w) позволяется тогда и только тогда, когда nb(p, b) (в w) свободен.
Если продвижение имеет место, то пакет p помещается в nb(p, b).

 

Theorem 5.7 Контроллер bgcBG
– беступиковый контроллер.

 

Доказательство. Если у вершины все буферы пусты,
генерация любого пакета позволяется, откуда следует, что bgcBG
– контроллер.

Для каждого b Î
B, определим класс буфера b
как длину самого длинного пути в BG , который заканчивается в b.
Заметим, что классы буферов на пути в BG (а точнее, на гарантированном
пути) строго возрастающие, т.е., класс буфера nb(p, b) больше, чем класс
буфера b.

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

Случай r
= R: Буфер b вершины u, имеющий самый большой из возможных
классов, не имеет исходящих ребер в BG. Следовательно, пакет, для которого
b – подходящий буфер, имеет пункт назначения u и может быть выведен,
когда он попадает в буфер b. Значит, ни один буфер класса R не содержит
тупиковых пакетов.

Случай r
< R: Выдвинем гипотезу, что для всех r’ таких, что r <
r’ £ R, ни
один буфер класса r’ не содержит тупиковый пакет (в достижимой конфигурации).
Пусть g – достижимая конфигурация с
пакетом p в буфере b класса r < R вершины u.
Если u – место назначения p, то p может быть выведен и, следовательно,
он не в тупике. Иначе, пусть nb(p, b) = c – следующий буфер на
гарантированном пути b, и заметим, что класс r’ буфера c
превосходит r. По гипотезе индукции, c не содержит тупиковых
пакетов, значит существует  конфигурация d,
достижимая из g, в которой c
– пуст. Из d  p может
продвинуться в c, и, по гипотезе индукции, p не тупиковый в
результирующей конфигурации d ‘.
Следовательно, p в конфигурации g
не в тупике.

Из доказательства видно, что если гарантированный путь
содержит "внутренние" ребра буферного графа (ребра между двумя
буферами одной вершины), то контроллер должен позволять дополнительные передвижения,
с помощью которых пакет помещается в буфер той же вершины. Обычно
гарантированный путь не содержит таких ребер. Они используются только для
увеличения эффективности продвижения, например, в следующей ситуации. Пакет p
размещается в буфере b1 вершины u и буфер nb(p, b1)
в вершине w занят. Но существует свободный буфер b2 в u,
который подходит для p; более того, nb(p, b2) в
вершине w свободен. В таком случае, пакет может быть перемещен через b2
и nb(p, b2).

Сейчас рассмотрим два примера использования буферных графов,
а именно, схема адресата(destination scheme) и схема сколько-было-переходов
(hops-so-far scheme).

Схема адресата. Схема адресата использует N
буферов в каждой вершине u, с буфером bu[v] для
каждого возможного адресата v. Вершина v называется цель
буфера bu[v]. Для этой схемы нужно
предположить, что алгоритмы маршрутизации продвигают все пакеты с адресатом v
по направленному дереву Tv , ориентированному по направлению
к v. (На самом деле это предположение может быть ослаблено; достаточно,
чтобы каналы, используемые для продвижения по направлению к v,
формировали ациклический подграф G.)

Буферный граф определяется как BGd = (B, ),
где bu[v1]bw[v2] Î тогда
и только тогда, когда v1 = v2 и uw –
ребро в Tv1. Чтобы показать, что BGd
– ациклический, заметим, что не существует ребер между буферами с
различными целями и, что буферы, с одинаковой целью v формируют дерево,
изоморфное Tv. Каждый путь P Î P с точкой
назначения v – путь в Tv, и по построению существует
путь в BGd из буферов с целью v, чей образ – P.
Этот путь выбирается в качества гарантированного. Это означает, что для пакета p
с адресатом v, сгенерированного в вершине u, fb(p) = bu[v],
и, если этот пакет должен продвинуться в w, то nb(p,b)
= bw[v].

 

Определение 5.8 Контроллер dest определяется
как bgcBG , с fb и nb определенными как в предыдущем параграфе.

 

Theorem 5.9 Существует беступиковый контроллер для
сети произвольной топологии, который использует N буферов в каждой вершине и
позволяет проводить пакеты через произвольно выбранные деревья  стока.

Доказательство. dest – беступиковый
контроллер, использующий такое количество буферов.    ð

Как было отмечено ранее,
требование маршрутизации по деревьям стока может быть ослаблено до требования
того, что пакеты с одинаковыми пунктами назначения посылаются через каналы,
которые формируют ациклический граф. Не достаточно, чтобы P содержало только простые пути, как это
показано на примере, данном на Рисунке 5.2. Здесь пакеты из u1
в v направляются через простой путь
á u1, w1,
u2, . . ., v ñ,
и пакете из u2 в v посылаются через простой путь

á u2, w2, u1,
. . ., v ñ.

Рисунок 5.2
маршрутизация, запрещенная для контроллера dest.

Каждый путь в P
простой; набор всех каналов, используемых для маршрутизации пакетов в v
содержит цикл á u1,
w1, u2, w2, u1,v
ñ. См. Упражнение 5.2.

Контроллер dest очень прост в использовании, но имеет
недостаток – для каждой вершины требуется большое количество буферов, а именно N.

 

Схема сколько-было-переходов. В этой схеме вершина u
содержит k +1 буфер
bu[0], . . ., bu[k].
Предполагается, что каждый пакет содержит счетчик переходов,
показывающий, сколько переходов от источника сделал пакет.

Буферный граф определяется как BGh = (B, ),
где bu[i] bw[j] Î тогда
и только тогда, когда  и uw Î E. Чтобы показать, что BGh
ациклический, заметим, что индексы буферов строго возрастают вдоль ребер BGh.
Т.к. длина каждого пути в P не более k
переходов, то существует соответствующий путь в буферном графе; если P =
u0, . .., ul (l£ k), то bu0[0],bu1
[1],…, bul[l]-путь в BGh с образом
P. Этот гарантированный путь описывается так: fb(p) = bu[0]
(для p, сгенерированного в u) и

(p, bu[i]) = bw[i +1]
для пакетов, которые должны быть продвинуты из u в w.

 

Определение 5.10 Контроллер hsf определяется
как bgcBGh , с fb и nb определенными в
предыдущем параграфе.

 

Theorem 5.11 Существует беступиковый контроллер
для сетей произвольной топологии, который использует D + 1 буфер в
каждой вершине (где D – диаметр сети), и требует, чтобы пакеты пересылались по
путям с минимальным числом переходов.

 

Доказательство.
Использование путей с минимальным числом переходов дает k = D. Тогда
hsf – беступиковый контроллер, использующий D +1 буфер в каждой
вершине. (Количество буферов даже может быть меньше, если узлы, расположенные
далеко друг от друга, не обмениваются пакетами.)       ð

В схеме
сколько-было-переходов буферы с индексом i используются для хранения
пакетов, которые сделали i переходов. Можно спректировать двойственная
схема сколько-будет-переходов ( hops-to-go), в которой буферы с
индексом i используются для хранения пакетов, которым надо сделать еще i
переходов до места назначения; см. Упражнение 5.3.

5.2.2
Ориентации G

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

Рисунок 5.3 Граф и
ациклическая ориентация.

 

Определение 5.12 Ациклическая ориентация G –
направленный ациклический граф, который получается ориентацией всех ребер G;
см. Рисунок 5.3.

Последовательность G1, …, GB
ациклических ориентаций G является покрытием из ациклических ориентаций размера
B для набора P путей, если каждый
путь P Î P  может быть записан как конкатенация B путей
P1, …, PB, где Pi  – путь
в Gi.

Когда возможно покрытие из ациклических ориентаций размера B,
может быть сконструирован контроллер, использующий только B буферов на
вершину. Пакет всегда генерируется в буфере bu[l] вершины u.
Пакет из буфера bu[i], который должен быть продвинут в
вершину w помещается в буфер bw [i], если дуга между u
и w направлена к w в Gi , и в буфер bw[i
+ 1], если дуга направлена к u в Gi.

 

Теорема 5.13 Если покрытие из ациклических
ориентаций для P размера B существует,
то существует беступиковый контроллер, использующий только B буферов на каждую
вершину.

 

Доказательство. Пусть G1. . .., GB
– покрытие, и bu[1], …, bu[B] – буферы
вершины u. Будем писать uw Î
, есди дуга uw направлена
к w в Gi, и wu Î , если дуга uw
направлена к u в Gi. Буферный граф определяется как BGa
=  (B, ), где bu[i]bw[j]
Î  тогда
и только тогда, когда uw Î
E и (i = j /\ uw Î
) или (i + 1 = j
/\ wu Î ). Чтобы показать, что
этот граф ациклический, отметим, что не существует циклов, содержащих буферы с
различными индексами, потому что нет дуг от данного буфера к другому с меньшим
индексом. Нет циклов с из буферов с одним и тем же индексом i , потому
что эти буферы назначаются в соответствии с ациклическим графом Gi.

Оставляем читателю (см. Упражнение 5.4) продемонстрировать,
что для каждого P Î P существует гарантированный путь с образом P,
и что такой путь описывается следующим образом:

Контроллер acoc = bgcBGa
– беступиковый контроллер, использующий B буферов в каждой вершине, что
доказывает теорему.                              ð

Коммутация пакетов в кольце. Покрытия из ациклических
ориентаций можно  использованы при построении беступиковых контроллеров для
нескольких классов сетей. Мы сначала представим контроллер для колец,
использующий только три буфера на вершину. Для следующей теоремы
предполагается, что веса каналов симметричны, т.е., wuw =wwu.

Теорема 5.14 Существует беступиковый контроллер
для кольцевой сети, который использует всего три буфера на вершину и позволяет
маршрутизировать пакеты через самые короткие пути.

Доказательство. Из Теоремы 5.13 достаточно дать
покрытие из ациклических ориентаций размером 3 для набора путей, который
включает самые короткие пути между всеми парами вершин.

Будем использовать следующую
нотацию. Для вершин u и v, dc(u, v) обозначает длину
пути из u в v по часовой стрелке и da(u, v) –
длина пути против часовой стрелки; dc(v, u) = da(u, v)
и d(u, v) = min(dc(u, v), da(u, v)) выполняется.
Сумма весом всех каналов называется C (периметр кольца) и
очевидно dc(u, v) + da(u, v) = C для всех u, v,
так что d(u, v)£ C/2.

 

Рисунок 5.4 покрытие
из ациклических ориентаций для кольца.

Во-первых рассмотрим простой случай, когда Существуют
вершины u и v с d(u, v) = C/2. G1 и G3
получаются ориентацией всех ребер по направлению к v, и G2
получается ориентацией всех ребер по направлению к u: см. Рисунок
5.4.

Самый короткий путь из u в v содержится в G1
или G3, и наименьший путь из v в u содержится в
G2. Пусть x, y – пара вершин, отличная от пары u,
v. Тогда, т.к.
d(x, y) £ C/2,
то существует самый короткий путь P между x и y, который
не содержит сразу и u, и v. Если P не сдержит ни u,
ни v , то он полностью содержится либо в G1 , либо в G2.
Если P содержит v , это конкатенация пути в G1
и пути в G2; если P содержит u, это
конкатенация пути в G2 и пути в G3.

Если не существует пары u, v с d(u, v) = C/2,
выберем пару, для которой d(u, v) как можно ближе к C /2. Теперь
может быть показано, что если существует пара x, y такая, что нельзя
найти самый короткий как конкатенацию путей в ориентациях покрытия, то d(x,
y) ближе к C /2, чем d(u,
v).                                                          ð

 

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

Теорема 5.15 Существует беступиковый контроллер
для сети в виде дерева, который использует только два буфера на вершину.

Доказательство. Из
Теоремы 5.13, достаточно дать ациклическую ориентацию для дерева, которая покрывает
все простые пути. Выберем произвольную вершину r, и получим T1
ориентацией всех ребер по направлению к r и T2 ориентацией
всех ребер от r; см. Рисунок 5.5.

Рисунок 5.5 Покрытие
из ациклических ориентаций для дерева.

Простой путь из u в v – конкатенация пути из u
к самому нижнему общему предку, который T1, и пути от
самого меньшего общего предка к v, который в T2. ð

5.3
Неструктурированные решения

Теперь мы обсудим класс контроллеров, предложенных Toueg и
Ullman [TU81]. Эти контроллеры не предписывают, в котором буфере должен быть
помещен пакет и  используют только простую локальную информацию типа счетчика переходов
или числа занятых буферов в узле.

5.3.1
Контроллеры с прямым и обратным счетом

Контроллер с прямым счетом (forward-count controller).
Пусть (для пакета p)  sp -количество переходов,
которые ему необходимо сделать до места назначения; конечно же 0 £ sp £ k выполняется. Не всегда необходимо
хранить sp в пакете, т.к. многие алгоритмы маршрутизации
хранят эту информацию в каждой вершине; см. например алгоритм Netchange Раздела
4.3. Для вершины u, fu обозначает число пустых буферов в u.
Конечно, 0 £ fu£ B всегда выполняется.

Определение 5.16 Контроллер FC (Forward-count)
принимает пакет p в вершине u тогда и только тогда, когда sp <
fu.

Контроллер принимает пакет, если пустых буферов в вершине
больше, чем количество переходов, которые нужно сделать пакету.

Теорема 5.17 Если B > k, то FC – беступиковый
контроллер.

Доказательство. Чтобы показать, что в пустой вершине
позволяется генерация пакета, заметим, что если все буферы вершины u
пусты, fu = B. Новому пакету нужно сделать не более k
переходов, так что из B > k следует, что пакет принимается.

Отсутствие тупиков FC будет показано методом от
противного: пусть g – достижимая
конфигурация контроллера. Получим конфигурацию d , применяя к g максимальную
последовательность из передвижений и выведения. В d ни один пакет не может двигаться, и, т.к. g – тупиковая конфигурация, то существует по
крайней мере один пакет, оставшийся в сети в конфигурации. Пусть p
– пакет в d с минимальным расстоянием
до пункта назначения, т.е., sp – наименьшее значение для всех
пакетов в d.

Пусть u – вершина, в которой размещается p.
Т.к. u не является пунктом назначения p (иначе p мог
бы быть выведен), то существует сосед w вершины u , в которую
нужно продвинуть p. Т. к. это передвижение не позволяется FC, то

sp-1³ fw

Из sp£
k и из предположения k < B следует, что fu <
B, что обозначает, что в вершине w располагается как минимум один
пакет (в конфигурации d ).
Из пакетов в w, пусть q будет последним пакетом, принятым
вершиной w, и пусть f’w обозначает количество пустых
буферов в w прямо перед принятием q вершиной w. Т.к. пакет
q теперь занимает один из этих f’w  буферов и (из
выбора q) все пакеты, принятые вершиной w после q были
выведены из w, то

f’w £
fw +1

Из принятие  q вершиной w следует sq
< f’w, и, комбинируя три полученных неравенства, получаем

sq <
f’w £ fw
+1£ sp,

что противоречит выбору p.                                      
ÿ

Контроллер с обратным счетом (backward-count controller).
Контроллер, " двойственный " FC , получается, когда решение,
принимать ли пакет, основано на количестве шагов, которые пакет уже сделал.
Пусть, для пакета p, tp – количество переходов,
которые он сделал от источника. Конечно, 0 £
tp < k всегда верно.

Определение 5.18 Контроллер BC (Backward-Count)
принимает пакет p в вершине u тогда и только тогда, когда tp
> k—fu.

Доказательство того, что BC – беступиковый
(Упражнение 5.6) очень похоже на доказательство  Теоремы 5.17.

5.3.2
Контроллеры с опережающим и отстающим состоянием

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

Контроллер с опережающим состоянием (forward-state
controller). Используем обозначение sp как в предыдущем
разделе. Для вершины u определим (как функцию состояния u) вектор
состояния , где j –
количество пакетов p в u с sp = s.

Определение 5.19 Контроллер FS (Forward-State)
принимает пакет p в вершине u с вектором состояния  тогда
и только тогда, когда

.

Теорема 5.20 Если B > k, то FS –
беступиковый.

Доказательство. Оставляем читателю показать, что
пустая вершина принимает все пакеты. Предположим, что существует достижимая
тупиковая конфигурация g, и
получим конфигурацию d ,
применяя максимальную последовательность из продвижений и выведения. Ни один
пакет не может передвигаться и по крайней мере один пакет остался в d. Выберем пакет p с минимальным
значением sp, и пусть u -вершина, в которой
располагается p и  w – вершина, в которую p должен продвинуться.
Пусть  – вектор состояния
вершины w в d.

Если w не содержит пакетом, то , откуда следует, что w
может принять p, что невозможно. Следовательно, w содержит по крайней
мере один пакет; из пакетов в w, пусть q – пакет, расположенный
ближе всего к пункту назначения, т.е., sq = min{s : js
> 0}. Покажем, что sq < sp, что
является противоречием. Из пакетов в w, пусть r – тот, который
был принят w позже всех, конечно, sq £ sr выполняется. Пусть  – вектор состояния w
прямо перед принятием r. Из принятия r следует

Когда  был
вектором состояния w, r был принят вершиной w. После этого пакеты
могли передвигаться из w, но все пакеты, принятые в w позже, чем r
были выведены (из выбора r). Из этого следует

Но это означает, что

Таким образом, принимая i = sq,

Теперь используем факт, что p не принята w,
т.е.,

Это дает неравенство

sp>sp-1

что и является
противоречием.                                    ð

 

Контроллер с отстающим состоянием (backward-state
controller.) Существует также и контроллер, "двойственный" FS,
который использует более детальную информацию, чем контроллер BC, и
позволяет больше передвижений. Пусть tp выбрано как раньше, и
определим вектор состояния как , где  it
равно количеству пакетов в вершине u , которые сделали t
переходов.

Определение 5.21 Контроллер BS (Backward-State)
принимает пакет p в вершине u с вектором состояния  тогда и только тогда,
когда

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

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

Лемма 5.22 Каждое передвижение, позволяемое FC
также позволяется FS.

Доказательство. Предположим, что принятие p
вершиной u позвляется контроллером FC. Тогда , так что для  i£ sp ,следует , откуда видно, что FS
позволяет передвижение.                                            D

В [TU81] было показано, что FC более либеральный, чем
BC. FS – более либеральный, чем BS, и BS более
либеральный, чем BC. Также было показано, что эти контроллеры самые
либеральные из всех, использующих такую же информацию.

5.4 Дальнейшие
проблемы

В результатах этой главы отметим, что число буферов,
необходимых контроллеру, всегда играло большую роль. Пропускная способность
обычно увеличивается, если доступно большое количество буферов. В неструктурированных
решениях дано только нижняя граница числа буферов; большее число может использоваться
без любой модификации. В структурированных решениях дополнительные буфера
должны так или иначе быть вставлены в буферный граф, что может быть выполнено
или статически или динамически. Если это выполнено статически,
каждый буфер имеет фиксированное расположение в буферном графе, т.е.,
создается  "более широкий" буферный граф, чем в примерах, приведенных
в Разделе 5.2.

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

В этой главе было принято, что пакеты имеют фиксированный
размер: буфера  одинаково большие и каждый буфер может содержать точно один
пакет. Проблему может также рассматривать, предположив, что пакеты могут иметь
различные размеры. Решения Раздела 5.3 были адаптированы к этому предположению
Bodlaender; см. [Bod86].

5.4.1
Топологические изменения

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

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

Контроллер dest. За конечное время после последнего
топологического изменения,  таблицы маршрутизации сводятся к таблицам свободным
от циклов. Даже не смотря на то, что ситуация циклического ожидания может
существовать во время вычисления таблиц, после завершения вычислений  буферный
граф снова становится ациклическим, и все пакеты хранятся в подходящих буферах.
Следовательно, когда таблицы маршрутизации вычислены,  возникшая в результате
конфигурация не содержит никаких тупиковых пакетов.

Контроллеры, подсчитывающие переходы. Рассмотрим
контроллер, который полагается на предположение, что пакет должен делать не
больше k переходов. Можно выбрать k достаточно большим, чтобы
гарантировать с большой вероятностью, что каждый пакет достигает адресата за k
переходов, даже если в течение путешествия от источника до адресата происходят
некоторые топологические изменения. Для всех пакетов, которые достигают своих
адресатов за k переходов,  контроллеры сколько-было-переходов, с
обратным счетом и с отстающим состоянием могут использоваться без какой-либо
модификации. Однако, возможно, что пакет не достиг адресата после k
переходов из-за неудачного образца топологических изменений и модификаций
таблиц. Если дело обстоит так, пакет сохраняется в неподходящем буфере, и он
будет навсегда блокирован в узле, отличном от адресата.

Такие ситуации могут быть решены только в кооперации с
протоколами более высокого уровня. Самое простое решение в том, чтобы отбросить
пакет. С точки зрения сквозного транспортного протокола, пакет теперь потерян;
но с этой потерей можно справиться с помощью протокола транспортного уровня,
как было показано в Разделе 3.2.

Отбрасывание пакетов также необходимо для выполнения
предположения Раздела 3.2 о том, что максимальное время жизни пакета m. Если пересылка пакета занимает не
более m0 единиц
времени, то из ограничения времени жизни пакета p следует ограничение k
=m /m0 на число переходов, которые может пройти пакет.

5.4.2 Другие
виды тупиков

В этой главе рассматривались только тупики с промежуточным
накоплением. Если предположения, сделанные в Разделе 5.1 имеют силу, тупики с
промежуточным накоплением – единственно возможные виды тупиков. В практических
сетях, однако, эти предположения не всегда выполняются и, как показали Merlin и
Schweitzer [MS80b], возможны другие типы тупиков. Merlin и Schweitzer рассматривают
четыре типа, а именно: тупик потомства, тупиком выпуска копии, тупик пошагового
продвижения, и тупик перетрансляции, и показывают, как можно избежать эти типы
тупиков расширением метода буферных графов.

Тупик потомства может возникнуть, когда пакет p
может создать в сети другой пакет q, например, отчет об отказе, если
произошло столкновение с испорченным каналом. Это ввело бы
причинно-следственные отношение между порождением нового пакета (q) и
пересылкой или выведением уже существующего (p), что нарушает
предположение Раздела 5.1, что сеть всегда позволяет пересылку и выведение пакета.

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

Тупик выпуска копии может возникнуть, когда источник
задерживает копию пакета, пока для пакета не получено (сквозное) подтверждение
от адресата. (Сравните с протоколом основанном на таймере из Раздела 3.2, и
предположите, что последовательность inp хранится в том же
самом пространстве памяти, которое используется механизмом маршрутизации для
временного хранения пакетов.) Это нарушает наше предположение (в Разделе 5.1),
что буфер становится пустым, когда пакет, занимающий его, продвигается.

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

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

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

Тупик перетрансляции может возникнуть в сетях, где
большие сообщения для передачи разделяются на более мелкие пакеты, и ни один
пакет не может быть удален из сети, пока все пакеты сообщения не достигли
адресата. (Сравните с протоколом скользящего окна Раздела 3.1, где слова
удаляются из outp только если были получены все слова с
меньшим индексом.) Это нарушает наше предположение, что выведение пакета в
адресате всегда возможно.

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

5.4.3 Лайфлок
(livelock)

Из определения тупиковых пакетов (Определение 5.2) следует,
что под управлением беступикового контроллера для каждого пакета существует по
крайней мере одно вычисление, в котором пакет выводится. Т.к. в общем случае
возможно большое количество различных вычислений, то это из этого не следует,
что каждый пакет в конечном счете доходит до адресата, даже в бесконечном вычислении,
как иллюстрируется Рисунок 5.6. Предположим, что u посылает в v
бесконечный поток пакетов, и каждый раз, как только буфер в w становится
пустым, принимается следующий пакет из u. Узел s имеет пакет для t,
который не заходит в тупик, потому что каждый раз, когда буфер в w
становится пустым, имеется возможное продолжение вычисления, в котором пакет
принимается вершиной w и посылается к t. Это возможно, но не
обязательно, и пакет может остаться в s навсегда. Ситуация этого вида
называется лайфлок.

Контроллер, обсуждаемый в этой главе, может быть расширен
так, чтобы вообще избежать лайфлоков.

Определение 5.23 Дана
сеть, контроллер con, и конфигурация g, пакет p заблокирован (лайфлок), если существует
бесконечная последовательность передвижений, применимых в g, в результате которых p не выводится.
Конфигурация g – конфигурация
лайфлока, если она содержит заблокированные пакеты.

Рисунок 5.6 Пример
лайфлока.

 

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

В оставшейся части этого подраздела будет доказана свобода
контроллера буферных графов от лайфлока;  в конце будут упомянуты расширения
неструктурированных решений.

Контроллер буферного графа. Можно продемонстрировать,
что контроллеры Раздела 5.2 лайфлок-свободны без каких-либо модификаций, если их
передвижения в бесконечной последовательности удовлетворяют ряду справедливых
предположений. Fl и F2 – сильные предположеня и F3 – слабое предположение.

Fl. Если порождение пакета p предпринимается
непрерывно, то каждое бесконечное вычисление, в котором fb (p) свободен
в бесконечно большом количестве конфигураций, содержит порождение p.

F2. Если в конфигурации g
пакет p должен быть послан от u до w, то каждое бесконечное
вычисление, начинающееся в g, в котором
nb (p, b) является свободным в бесконечно большом количестве конфигураций,
содержит пересылку p.

F3. Если пакет p находится в своем пункте назначения
в конфигурации g, то каждое бесконечное
вычисление, начинающееся в g, содержит
выведение p.

Лемма 5.24 Если справедливые предположения F2
и F3 удовлетворяются в каждом бесконечном вычислении bgc, то
каждый буфер свободен бесконечно часто.

Доказательство. Доказывать будем индукцией сверху
вниз по классам буферов. Как в доказательстве Теоремы 5.7, пусть R –
наибольший буферный класс. Напомним, что в конфигурациях, достижимых под управлением
bgc, все пакеты располагаются в подходящих буферах.

Случай r = R: Буфер класса R не
имеет исходящих ребер, и, следовательно, пакет из такого буфера достигает
пункта назначения. Следовательно, по предположению F3, после каждой
конфигурации, в которой такой буфер занят, будет конфигурация, в которой буфер
свободен. Отсюда следует, что он пуст в бесконечно большом количестве
конфигураций.

Случай r < R: Пусть g – конфигурация, в которой буфер b
класса r < R занят пакетом p. Если p достиг
своего пункта назначения, то позже будет конфигурация, в которой b будет
пустым из F3. Иначе, p должен быть продвинут в буфер nb(p, b)
класса r’ > r. По индукции, в каждом бесконечном вычислении,
начинающемся в g, этот буфер пуст
бесконечно часто. Из этого следует (по F2), что p будет передан и,
следовательно, будет конфигурация g,
после которой b будет пуст.

Теорема 5.25 Если справедливые предположения F1,
F2 и F3 удовлетворяются, то в каждом бесконечном вычислении каждый пакет,
предлагаемый сети, будет выведен из своего пункта назначения.

Доказательство. По Лемме 5.24 все буферы пусты в
бесконечно большом количестве конфигураций. Значит (по Fl) каждый паке, который
продолжает предлагаться сети, будет сгенерирован. По F2 он будет продвигаться,
пока не достигнет своего пункта назначения.           ð

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

Неструктурированные решения. Контроллеры Раздела 5.3
нужно модифицировать, чтобы они стали лайфлок-свободными. Это может быть
показано моделированием бесконечного вычисления, в котором непрерывный поток
пакетов заставляет контроллер запрещать пересылку некоторого пакета. Toueg
[TouSOb] представляет такое вычисление (для FC) и представляет
модификацию FS (подобную представленной здесь для контроллеров буферных
графов), которая является лайфлок-свободной.

Упражнения к
Главе 5

Раздел 5.1

Упражнение 5.1 Покажите, что не существует
беступикового контроллера, который использует только один буфер на вершину и
позволяет каждой вершине посылать пакеты по крайней мере одной другой вершине.

Раздел 5.2

Упражнение 5.2 Покажите, что dest не
является беступиковым, если маршрутизация пакетов осуществляется как на Рисунке
5.2.

Упражнение 5.3 (Схема сколько-будет-переходов) Дайте
буферный граф и функции fb и nb для контроллера, который использует буфер bu[i]
для хранения пакетов, которым нужно сделать еще i переходов по направлению к
своим пунктам назначения. Каков буферный класс bu [i] ? Нужно ли
хранить счетчик переходов в каждом пакете?

Упражнение 5.4 Закончите доказательство того, что
граф BGa (определенный в доказательстве Теоремы 5.13)- в самом деле
буферный граф, т.е., для каждого пути P Î
P существует гарантированный путь
с образом P. Покажите, что, как утверждалось, fb и nb в самом деле описывают
путь в BGa.

Проект 5.5 Докажите, что существует беступиковый
контроллер, для коммутации пакетов в  гиперкубе, который использует всего два
буфера на вершину и позволяет маршрутизировать пакеты через минимальные пути.
Можно ли получить набор используемых путей посредством алгоритма интервальной
маршрутизации (Подраздел 4.4.2)? Можно ли использовать схему линейной интервальной
разметки?

Раздел 5.3

Упражнение 5.6 Докажите, что BC и
BS – беступиковые контроллеры.

 Упражнение 5.7 Докажите, каждое
передвижение, позволяемое BC, также позволяется FC.

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

6 Волновые
алгоритмы и алгоритмы обхода

При
разработке распределенных алгоритмов для различных приложений часто в качестве
подзадач возникает несколько общих проблем для сетей процессов. Эти
элементарные задачи включают в себя широковещательную рассылку информации – broadcasting (например, посылка начального или заключительного
сообщения), достижение глобальной синхронизации между процессами, запуск
выполнения некоторого события в каждом процессе, или вычисление функции,
входные данные которой распределены между процессами. Эти задачи всегда
решаются путем пересылки сообщений согласно некоторой, зависящей от топологии
схеме, которая гарантирует участие всех процессов. Эти задачи настолько
фундаментальны, что можно дать решения более сложных задач, таких как выбор
(Глава 7), обнаружение завершения (Глава 8), или взаимное исключение, в которых
связь между процессами осуществляется только через эти схемы передачи сообщений.

Важность
схем передачи сообщений, называемых далее волновыми алгоритмами, оправдывает их
рассмотрение отдельно от конкретного прикладного алгоритма, в который они могут
быть включены. В этой главе формально определяются волновые алгоритмы
(Подраздел 6.1.1) и доказываются некоторые общие результаты о них (Подраздел
6.1.2). Замечание о том, что те же самые алгоритмы могут использоваться для
всех основных задач, изложенных выше, т.е. широковещание, синхронизация и
вычисление глобальных функций, будет формализовано (Подразделы 6.1.3-5). В
Разделе 6.2 представлены некоторые широко используемые волновые алгоритмы. В
Разделе 6.3 рассматриваются алгоритмы обхода; это волновые алгоритмы, в которых
все события вычисления алгоритма совершенно упорядочены каузальным
отношением. В Разделе 6.4 представлены несколько алгоритмов для распределенного
поиска в глубину.

Несмотря
на то, что волновые алгоритмы обычно используются как подзадачи в более сложных
алгоритмах, их полезно рассматривать отдельно. Во-первых, введение новых
понятий облегчает последующее рассмотрение более сложных алгоритмов, т.к.
свойства их подзадач уже изучены. Во-вторых, определенные задачи в
распределенных вычислениях могут быть решены с помощью универсальных конструкций,
в качестве параметров которых могут использоваться конкретные волновые
алгоритмы. Тот же метод может использоваться для получения алгоритмов для
различных сетевых топологий или для различных предположений о начальном знании процессов.
Эта глава основана на [Tel91b, Раздел 4.2], где понятие волновых алгоритмов
изучается под названием общие алгоритмы.

6.1  Определение и
использование волновых алгоритмов

В
пределах этой главы считается, если не указано обратное, что сетевая топология
фиксирована (не происходит топологических перемен), не ориентирована (каждый
канал передает сообщения в обоих направлениях) и связна (существует путь между
любыми двумя процессами). Множество всех процессов обозначено через P, а множество каналов – через E. Как и в
предыдущих главах, предполагается, что система использует асинхронную передачу
сообщений и не существует понятия глобального или реального времени. Алгоритмы
из этой главы также могут быть использованы в случае синхронной передачи сообщений
(возможно с некоторыми изменениями во избежание тупиков) или с часами
глобального времени, если они доступны. Однако некоторые более общие теоремы в
этих случаях неверны; см. Упражнение 6.1.

6.1.1  Определение волновых алгоритмов

Как
отмечалось в Главе 2, распределенные алгоритмы обычно допускают большой набор
возможных вычислений благодаря недетерминированности как в процессах, так и  в
подсистеме передачи. Вычисление – это набор событий, частично упорядоченных
отношением каузального (причинно-следственного) предшествования p; см.
Определение 2.20. Количество событий в вычислении C обозначается через |C|, а
подмножество событий, происходящих в процессе p, обозначается через Cp.
Считается, что существует особый тип внутренних событий, называемый decide
(принять решение); в алгоритмах этой главы такое событие представляется
просто утверждением decide. Волновой алгоритм обменивается
конечным числом сообщений и затем принимает решение, которое каузально зависит
от некоторого события в каждом процессе.

Определение
6.1 Волновой алгоритм – это распределенный алгоритм, который удовлетворяет
следующим трем требованиям:

a)   Завершение.
Каждое вычисление конечно:

                                 " C :
|C| < ¥

b)   Принятие
решения. Каждое вычисление содержит хотя бы одно событие decide:

                                 " C : $
e Î C : e – событие decide.

c)   Зависимость.
В каждом вычислении каждому событию decide каузально предшествует
какое-либо событие в каждом процессе:

                   " C : " e Î C :
( e – событие decide Þ  " q Î P  $ f Î Cq :
f p e).

Вычисление
волнового алгоритма называется волной. Кроме того, в вычислении
алгоритма различаются инициаторы, также называемые стартерами, и не-инициаторы,
называемые последователями. Процесс является инициатором, если он
начинает выполнение своего локального алгоритма самопроизвольно, т.е. при
выполнении некоторого условия, внутреннего по отношению к процессу.
Не-инициатор включается в алгоритм только когда прибывает сообщение и вызывает
выполнение локального алгоритма процесса. Начальное событие инициатора –
внутреннее событие или событие посылки сообщения, начальное событие
не-инициатора – событие получения сообщения.

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

1)  
Централизация. Алгоритм называется централизованным,
если в каждом вычислении должен быть ровно один инициатор, и децентрализованным,
если алгоритм может быть запущен произвольным подмножеством процессов.
Централизованные алгоритмы также называют алгоритмами одного источника,
а децентрализованные – алгоритмами многих источников. Как видно из
Таблицы 6.20, централизация существенно влияет на сложность волновых алгоритмов.

2)  
Топология. Алгоритм может
быть разработан для конкретной топологии, такой как кольцо, дерево, клика и
т.д.; см. Подраздел 2.4.1 и Раздел B.2.

3)  
Начальное знание. Алгоритм может предполагать доступность
различных типов начального знания в процессах; см. Подраздел 2.4.4. Примеры требуемых
заранее знаний:

(a) Идентификация процессов. Каждому процессу
изначально известно свое собственное уникальное имя.

(b) Идентификация соседей. Каждому процессу изначально
известны имена его соседей.

(c) Чувство направления (sense of
direction). См. Раздел B.3.

4)  
Число решений. Во всех волновых алгоритмах этой главы в
каждом процессе происходит не более одного решения. Количество процессов, которые
выполняют событие decide, может быть различным; в некоторых алгоритмах
решение принимает только один процесс, в других – все процессы. В древовидном
алгоритме (Подраздел 6.2.2) решают ровно два процесса.

5)  
Сложность. Меры сложности, рассматриваемые в этой главе,
это количество передаваемых сообщений (message complexity), количество передаваемых
бит (bit complexity) и время, необходимое для одного вычисления (определено в
Разделе 6.4). См. также Подраздел 2.4.5.

Каждый
волновой алгоритм в этой главе будет дан вместе с используемыми переменными и,
в случае необходимости, с информацией, передаваемой в сообщениях. Большинство
этих алгоритмов посылают «пустые сообщения», без какой-либо реальной
информации: сообщения передают причинную связь, а не информацию. Алгоритмы 6.9,
6.11, 6.12 и 6.18 используют сообщения для передачи нетривиальной информации.
Алгоритмы 6.15 и 6.16/6.17 используют различные типы сообщений; при этом
требуется, чтобы каждое сообщение содержало 1-2 бита для указания типа
сообщения.

Обычно
при применении волновых алгоритмов в сообщение могут быть включены
дополнительные переменные и другая информация.[AK1] 
Многие приложения используют одновременное или последовательное распространение
нескольких волн; в этом случае в сообщение должна быть включена информация о
волне, которой оно принадлежит. Кроме того, процесс может хранить дополнительные
переменные для управления волной, или волнами, в которых он в настоящее время активен.

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

6.1.2  Элементарные результаты о волновых алгоритмах

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

Структурные
свойства волн. Во-первых, каждому событию в вычислении предшествует событие
в инициаторе.

Лемма
6.2  Для любого события e Î
C существует инициатор p и событие f в Cp такое,
что f p e.

Доказательство.
Выберем в качестве f минимальный элемент в предыстории e, т.е. такой, что
f p e и не
существует f¢ p f. Такое f существует, поскольку
предыстория каждого события конечна. Остается показать, что процесс p, в котором
находится f, является инициатором. Для начала, заметим, что f – это первое
событие p, иначе более раннее событие p предшествовало бы f. Первое событие
не-инициатора – это событие получения сообщения, которому предшествовало бы
соответствующее событие посылки сообщения, что противоречит минимальности f.
Следовательно, p является инициатором.

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

Лемма
6.3  Пусть C – волна с одним инициатором p; и пусть
для каждого не-инициатора q  fatherq – это сосед q,
от которого q получает сообщение в своем первом событии. Тогда граф T =
(P, ET), где ET =
{qr: q ¹ p &
r = fatherq } – остовное дерево, направленное к p.

Доказательство.
Т.к. количество вершин T превышает количество ребер на 1, достаточно
показать, что T не содержит циклов. Это выполняется, т.к. если eq –
первое событие в q, из того, что qr Î
ET следует, что er p eq,
а p – отношение частичного
порядка.

В
качестве события f в пункте (3) Определения 6.1 может быть выбрано событие
посылки сообщения всеми процессами q, кроме того, где происходит событие decide.

Лемма
6.4  Пусть C – волна, а dp Î C – событие decide в
процессе p. Тогда

                     " q ¹ p: $ f Î Cq: ( f p dp  &  f –
событие send)

Доказательство.
Т.к. C – это волна, существует событие f ÎCq,
которое каузально предшествует dp; выберем в качестве f последнее
событие Cq, которое предшествует dp. Чтобы показать, что
f – событие send, отметим, что из определения каузальности (Определение
2.20) следует, что существует последовательность (каузальная цепочка)

f =
e0, e1, …, ek = dp,

такая, что для
любого i < k, ei и ei+1 – либо
последовательные события в одном процессе, либо пара соответствующих событий
send-receive. Т.к. f – последнее событие в q, которое предшествует dp,
e1 происходит в процессе, отличном от q, следовательно f – событие send.

Рис.6.1  Включение процесса в неиспользуемый
канал.

Нижние
границы сложности волн. Из леммы 6.4 непосредственно следует, что нижняя
граница количества сообщений, которые передаются в волне, равна N-1. Если
событие decide происходит в единственном инициаторе волны (что
выполняется всегда в случае алгоритмов обхода), граница равна N сообщениям, а
волновые алгоритмы для сетей произвольной топологии используют не менее |E|
сообщений.

Теорема
6.5  Пусть C – волна с одним инициатором p, причем событие
decide dp происходит в p. Тогда в C передается
не менее N сообщений.

Доказательство.
По лемме 6.2 каждому событию в C предшествует событие в p, и, используя каузальную
последовательность, как в доказательстве леммы 6.4, нетрудно показать, что в p
происходит хотя бы одно событие send. По лемме 6.4 событие send
также происходит во всех  других процессах, откуда количество посылаемых
сообщений составляет не меньше N.

Теорема
6.6 Пусть A – волновой алгоритм для сетей произвольной топологии
без начального знания об идентификации соседей. Тогда A передает не
менее |E| сообщений в каждом вычислении.

Доказательство.
Допустим, A содержит вычисление C, в котором передается менее |E| сообщений;
тогда существует канал xy, по которому в C не передаются сообщения; см. Рис.6.1.
Рассмотрим сеть G¢, полученную
путем включения одного узла z в канал между x и y. Т.к. узлы не имеют знания о
соседях, начальное состояние x и y в G¢
совпадает с их начальным состоянием в G. Это верно и для всех остальных узлов
G. Следовательно, все события C могут быть применены в том же порядке, начиная
с исходной конфигурации G¢, но
теперь событию decide не предшествует событие в z.

В
Главе 7 будет доказана улучшенная нижняя граница количества сообщений
децентрализованных волновых алгоритмов для колец и сетей произвольной топологии
без знания о соседях; см. Заключение 7.14 и 7.16.

6.1.3  Распространение информации
с обратной связью

В
этом подразделе будет продемонстрировано применение волновых алгоритмов для
случая, когда некоторая информация должна быть передана всем процессам и
определенные процессы должны быть оповещены о завершении передачи. Эта задача
распространения информации с обратной связью (PIF – propagation of information
with feedback) формулируется следующим образом [Seg83]. Формируется подмножество
процессов из тех, кому известно сообщение M (одно и то же для всех процессов),
которое должно быть распространено, т.е. все процессы должны принять M.
Определенные процессы должны быть оповещены о завершении передачи; т.е.
должно быть выполнено специальное событие notify, причем оно может быть
выполнено только когда все процессы уже получили сообщение M. Алгоритм должен
использовать конечное количество сообщений.

Оповещение
в PIF-алгоритме можно рассматривать как событие decide.

Теорема
6.7 Каждый PIF-алгоритм является волновым алгоритмом.

Доказательство.
Пусть P – PIF-алгоритм. Из формулировки задачи каждое вычисление P должно быть
конечным и в каждом вычислении должно происходить событие оповещения (decide).
Если в некотором вычислении P происходит оповещение dp, которому не
предшествует никакое событие в процессе q, тогда из Теоремы 2.21 и Аксиомы 2.23
следует, что существует выполнение P, в котором оповещение происходит до
того, как q принимает какое-либо сообщение, что противоречит требованиям.

Мы
должны иметь в виду, что теорема 2.21 выполняется только для систем с
асинхронной передачей сообщений; см. Упражнение 6.1.

Теорема
6.8 Любой волновой алгоритм может использоваться как PIF-алгоритм.

Доказательство.
Пусть A – волновой алгоритм. Чтобы использовать A как PIF-алгоритм, возьмем в
качестве процессов, изначально знающих M, стартеры (инициаторы) A. Информация M
добавляется к каждому сообщению A. Это возможно, поскольку по построению
стартеры A знают M изначально, а последователи не посылают сообщений, пока не
получат хотя бы одно сообщение, т.е. пока не получат M. Событию decide в
волне предшествуют события в каждом процессе; следовательно, когда оно
происходит, каждый процесс знает M, и событие decide можно считать
требуемым событием notify в PIF-алгоритме.

Построенный
PIF-алгоритм имеет такую же сложность сообщений, как и алгоритм A и обладает
всеми другими качествами A, описанными в Подразделе 6.1.1, кроме битовой
сложности. Битовая сложность может быть уменьшена путем добавления M только к первому
сообщению, пересылаемому через каждый канал. Если w – количество бит в M,
битовая сложность полученного алгоритма превышает битовую сложность A на w*|E|.

6.1.4  Синхронизация

В
этом разделе будет рассмотрено применение волновых алгоритмов для случаев,
когда должна быть достигнута глобальная синхронизация процессов. Задача
синхронизации (SYN) формулируется следующим образом [Fin79]. В каждом процессе
q должно быть выполнено событие aq, и в некоторых процессах должны
быть выполнены события bp, причем все события aq должны
быть выполнены по времени раньше, чем будет выполнено какое-либо событие bp.
Алгоритм должен использовать конечное количество сообщений.

В
SYN-алгоритмах события bp будут рассматриваться как события decide.

Теорема
6.9 Каждый SYN-алгоритм является волновым алгоритмом.

Доказательство. 
Пусть S – SYN-алгоритм. Из формулировки задачи каждое вычисление S должно быть
конечным и в каждом вычислении должно происходить событие bp (decide).
Если в некотором вычислении S происходит событие bp, которому
каузально не предшествует aq, тогда (по Теореме 2.21 и Аксиоме 2.23)
существует выполнение S, в котором bp происходит ранее aq.

Теорема
6.10 Любой волновой алгоритм может использоваться как SYN-алгоритм.

Доказательство. 
Пусть A – волновой алгоритм. Чтобы преобразовать A в SYN-алгоритм, потребуем,
чтобы каждый процесс q выполнял aq до того, как q пошлет сообщение в
A или примет решение в A. Событие bp происходит после события decide
в p. Из леммы 6.4, каждому событию decide каузально предшествует aq
для любого q.

Построенный
SYN-алгоритм имеет такую же сложность сообщений, как и A, и обладает всеми другими
свойствами A, описанными в Подразделе 6.1.1.

6.1.5  Вычисление функций
инфимума

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

Если
(X, £) – частичный порядок, то c
называют инфимумом a и b, если  c £ a,
c £ b, и " d : ( d £ a & d £ b Þ
d £ c). Допустим, что X
таково, что инфимум всегда существует; в этом случае инфимум является
единственным и обозначается как a Ù b.
Т.к. Ù – бинарный оператор,
коммутативный (a Ù b =
b Ù a)  и ассоциативный
(т.е. a Ù (b Ù c) = (a Ù b) Ù c), операция может быть обобщена на конечные множества:

inf
{ j1, …, j k} = j1 Ù … Ù j k
.

Задача
вычисления инфимума формулируется следующим образом. Каждый процесс q содержит
вход jq, являющийся элементом частично упорядоченного множества X.
Потребуем, чтобы определенные процессы вычисляли значение  inf {jq :
q Î P} и чтобы эти процессы знали, когда вычисление завершается.
Они записывают результат вычисления в переменную out и после
этого не могут изменять ее значение.

Событие
write, которое заносит значение в out, рассматривается в
INF-алгоритме как событие decide.

Теорема
6.11 Каждый INF-алгоритм является волновым алгоритмом.

Доказательство. 
Пусть I – INF-алгоритм. Предположим, что существует вычисление C алгоритма I с
начальной конфигурацией ¡, в
котором p записывает значение J в outp и этому событию write
не предшествует никакое событие в q. Рассмотрим начальную конфигурацию ¡¢, которая аналогична ¡ за исключением того, что q имеет
другой вход jq¢,
выбранный так, что jq¢ <
J.  Так как никакое применение входа q не предшествует каузально событию write
процесса p в C, все события C, предшествующие событию write, применимы в
том же порядке, начиная с ¡¢.
В полученном вычислении p записывает ошибочный результат J, так же как в C.

Теорема
6.12 Любой волновой алгоритм может быть использован для
вычисления инфимума.

Доказательство. 
Допустим, что дан волновой алгоритм A. Назначим каждому процессу q дополнительную
переменную vq, которой придадим начальное значение jq. Во
время волны эти переменные переприсваиваются следующим образом. Всякий раз,
когда процесс q посылает сообщение, текущее значение vq включается в
сообщение. Всякий раз, когда процесс q получает сообщение со значением v, vq
присваивается значение  vq Ù v.
Когда в процессе p происходит событие decide, текущее значение vp
заносится в outp.

Теперь
нужно показать, что в результат заносится правильное значение. Обозначим
правильный ответ через J, т.е. J = inf { jq: q Î P}.
Для события a в процессе q обозначим через v(a) значение vq
сразу после выполнения a. Т.к. начальное значение vq равно jq,
и в течение волны оно только уменьшается, неравенство v(a) £ jq сохраняется для
каждого события a в q. Из присваивания v следует, что для событий a и b,
a p b Þ v(a) ³ v(b). Кроме того, т.к.
v всегда вычисляется как инфимум двух уже существующих величин, неравенство
J £ v выполняется для
всех величин в течение волны. Таким образом, если d – событие decide в
p, значение v(d) удовлетворяет неравенству J £ v(d) и, т.к. событию
d предшествует хотя бы одно событие в каждом процессе q, v(d) £ jq для всех q. Отсюда
следует, что J = v(d).

Построенный
INF-алгоритм обладает всеми свойствами A, кроме битовой сложности, поскольку к
каждому сообщению A добавляется элемент X. Понятие функции инфимума может
показаться довольно абстрактным, но фактически многие функции могут быть
выражены через функцию инфимума, как показано в [Tel91b, Теорема 4.1.1.2].

Аксиома
6.13 (Теорема об инфимуме)  Если * – бинарный оператор на
множестве X, причем он:

(1) коммутативен,
т.е. a * b = b * a,

(2) ассоциативен,
т.е. (a * b) * c = a * (b * c), и

(3) идемпотентен,
т.е. a * a = a

то существует
отношение частичного порядка £
на X такое, что * – функция инфимума.

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

Заключение
6.14 &, Ú, min, max, НОД,
НОК, Ç и È величин, локальных по отношению к
процессам, могут быть вычислены за одну волну.

Вычисление
операторов, которые являются коммутативными и ассоциативными, но не идемпотентны,
рассматривается в Подразделе 6.5.2.

6.2  Волновые алгоритмы

В
следующих трех разделах будет представлено несколько волновых алгоритмов и
алгоритмов обхода. Все тексты алгоритмов даны для процесса p.

 

6.2.1  Кольцевой алгоритм

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

Алгоритм
является централизованным; инициатор посылает сообщение <tok>
(называемое маркером) вдоль цикла, каждый процесс передает его дальше и когда
оно возвращается к инициатору, инициатор принимает решение; см. Алгоритм 6.2.

Для
инициатора:

          begin  
send <tok> to Nextp;  receive <tok>; decide
end

Для
не-инициатора:

          begin 
receive <tok>; send <tok> to Nextp end

Алгоритм 6.2 Кольцевой алгоритм.

Теорема
6.15 Кольцевой алгоритм (Алгоритм 6.2) является волновым алгоритмом.

Доказательство.
Обозначим инициатор через p0. Так как каждый процесс посылает не
более одного сообщения, алгоритм передает в целом не больше N сообщений.

За
ограниченное количество шагов алгоритм достигает заключительной конфигурации. В
этой конфигурации p0 уже переслал маркер, т.е. выполнил оператор send
в своей программе. Кроме того, ни одно сообщение <tok> не передается
ни по одному каналу, иначе оно может быть получено и конфигурация не будет
заключительной. Также, ни один процесс, кроме p0, не «задерживает»
маркер (т.е. получил, но не передал дальше <tok>), иначе процесс
может послать <tok> и конфигурация не будет конечной. Следовательно,
(1) p0 отправил маркер, (2) для любого p, пославшего маркер, Nextp
получил маркер, и (3) каждый p ¹ p0,
получивший маркер, отправил маркер. Из этого и свойства Next следует, что каждый
процесс отправил и получил маркер. Т.к. p0 получил маркер и конфигурация
конечна, p0 выполнил оператор decide.

Получение
и отправка <tok> каждым процессом p ¹ p0 предшествует получению маркера
процессом p0, следовательно, условие зависимости выполнено.

6.2.2  Древовидный алгоритм

В
этом разделе представлен алгоритм для древовидной сети. Этот же алгоритм может
быть использован для сетей произвольной топологии, если доступно остовное
дерево сети. Предполагается, что алгоритм инициируют все листья дерева. Каждый
процесс в алгоритме посылает ровно одно сообщение. Если процесс получил
сообщение по всем инцидентным каналам, кроме одного (это условие изначально
выполняется для листьев), процесс отправляет сообщение по оставшемуся каналу.
Если процесс получил сообщения через все инцидентные каналы, он принимает
решение; см. Алгоритм 6.3.

var recp[q] 
for each q Î Neighp
:    boolean     init false ;

       (*
recp[q]  = true, если p получил сообщение от q *)

begin   while 
# {q : recp[q]  is  false} > 1 do

                
begin  receive <tok> from q ;  recp[q] := true 
end ;

            (*
Теперь остался один q0, для которого recp[q0]
= false *)

            send 
<tok>  to q0  with recp[q0]  is false
;

       x
: receive <tok>  from q0 ;  recp[q0]
:= true ;

            decide

            (*
Сообщить другим процессам о решении:

                 
forall  q Î Neighp,
q ¹ q0  do send
<tok>  to q *)

end

Алгоритм 6.3 Древовидный алгоритм.

Чтобы
показать, что этот алгоритм является волновым, введем некоторые обозначения.
Пусть fpq – событие, где p посылает сообщение q, а gpq –
событие, где q получает сообщение от p. Через Tpq обозначим
подмножество процессов, которые достижимы из p без прохождения по дуге pq
(процессы на стороне p дуги pq); см. Рис.6.4.

Из
связности сети следует, что (см. Рис.6.4)

Tpq
=     и     P =

Рис. 6.4  Поддеревья Tpq.

Оператор
forall в комментариях в Алгоритме 6.3 будет обсуждаться в конце этого
подраздела; в следующей теореме речь идет об алгоритме без этого оператора.

Теорема
6.16 Древовидный алгоритм (Алгоритм 6.3) является волновым алгоритмом.

Доказательство.
Т.к. каждый процесс посылает не более одного сообщения, в целом алгоритм использует
не более N сообщений. Отсюда следует, что алгоритм достигает заключительной
конфигурации ¡ за конечное число
шагов; мы покажем, что в ¡ хотя
бы один процесс выполняет событие decide.

Пусть
F – количество битов rec со значением false в ¡, а K – количество процессов, которые
уже послали сообщения в ¡. Т.к. в
¡ не передается ни одно сообщение
(иначе ¡ не была бы
заключительной), F = (2N-2) – K; общее число битов rec равно 2N-2,
а K из них равны true.

Предположим,
что ни один процесс в ¡ не принял
решения. N-K процессов, которые еще не послали сообщение в ¡, содержат хотя бы по два бита rec,
равных false; иначе они бы могли послать сообщение, что противоречит
тому, что ¡ – заключительная
конфигурация. K процессов, которые послали сообщение в ¡, содержат хотя бы один бит rec, равный false;
иначе они могли бы принять решение, что противоречит тому, что ¡ – заключительная конфигурация. Итак,
F ³ 2(N-K) + K, а из
(2N-2) – K ³ 2(N-K) + K
следует, что -2 ³ 0; мы
пришли к противоречию, следовательно, хотя бы один процесс в ¡ принимает решение. См. Упражнение
6.5.

 Наконец,
нужно показать, что решению предшествует событие в каждом процессе. Пусть fpq
– событие, где p посылает сообщение q, а gpq – событие, где q
получает сообщение от p. Применяя индукцию по событиям получения сообщений,
можно доказать, что " s Î Tpq $ e Î
Cs: e p gpq.

Предположим,
что это выполняется для всех событий получения сообщений, предшествующих gpq.
Из того, что событию gpq предшествует fpq (в процессе p),
и из алгоритма p следует, что для всех r Î
Neighp при r ¹ q,
grp предшествует fpq. Из гипотезы индукции следует, что
для всех таких r и для всех s Î
Trp существует событие e Î
Cs, где e p
grp, следовательно, e p
gpq.

Решению
dp в p предшествуют grp для всех r Î Neighp, откуда следует,
что " s Î P
$ e Î Cs : e p dp.

Читатель
может смоделировать вычисление алгоритма на небольшом дереве (например, см.
дерево на Рис.6.4) и самостоятельно убедиться в справедливости следующих
замечаний. В Алгоритме 6.3 существует два процесса, которые получают сообщения
через все свои каналы и принимают решение; все остальные тем временем ожидают
сообщения с счетчиком команд, установленным на x, в заключительной
конфигурации. Если к программе добавить оператор forall (в скобках
комментария в Алгоритме 6.3), то все процессы принимают решение и в конечной
конфигурации каждый процесс находится в конечном состоянии. Модифицированная
программа использует 2N-2 сообщений.

6.2.3  Эхо-алгоритм

Эхо-алгоритм
– это централизованный волновой алгоритм для сетей произвольной топологии.
Впервые он был представлен Чангом [Chang; Cha82] и поэтому иногда называется
эхо-алгоритмом Чанга. Более эффективная версия, которая и представлена здесь,
была предложена Сегаллом [Segall; Seg83].

Алгоритм
распространяет сообщения <tok> по всем процессам, таким образом
определяя остовное дерево, как определено в Лемме 6.3. Маркеры «отражаются»
обратно через ребра этого дерева аналогично потоку сообщений в древовидном
алгоритме. Алгоритм обозначен как Алгоритм 6.5.

Инициатор
посылает сообщения всем своим соседям. После получения первого сообщения
не-инициатор пересылает сообщения всем своим соседям, кроме того, от которого
было получено сообщение. Когда не-инициатор получает сообщения от всех своих
соседей, эхо пересылается родителю (father). Когда инициатор получает сообщения
от всех своих соседей, он принимает решение.

var 
recp         :  integer   init  0 ;      (* Счетчик полученных
сообщений *)

      
fatherp  :  P            init 
udef ;

Для инициатора:

          begin  forall  q
Î Neighp  do 
send <tok>  to q ;

                      while 
recp < # Neighp  do

                                begin 
receive <tok> ;  recp := recp + 1  end
;

                      decide

          end ;

Для не-инициатора:

          begin  receive
<tok>  from neighbor q ;  fatherp := q ;  recp
:= recp + 1 ;

                      forall 
q Î Neighp,  q ¹ fatherp  do  send
<tok>  to q ;

                      while 
recp < # Neighp  do

                                begin 
receive <tok> ;  recp := recp + 1  end
;

                      send <tok> 
to fatherp

          end

Алгоритм 6.5 Эхо-алгоритм.

Теорема
6.17 Эхо-алгоритм (Алгоритм 6.5) является волновым алгоритмом.

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

Для
этой конфигурации определим (подобно определению в лемме 6.3) граф T = (P,ET), где pq Î ET Û fatherp = q. Чтобы показать, что этот граф
является деревом, нужно показать, что количество ребер на единицу меньше, чем
количество вершин (Лемма 6.3 утверждает, что T – дерево, но предполагается, что
алгоритм является волновым, что нам еще нужно доказать). Отметим, что каждый
процесс, участвующий в C, посылает сообщения всем своим соседям, кроме соседа,
от которого он получил первое сообщение (если процесс – не-инициатор). Отсюда
следует, что все его соседи получают хотя бы одно сообщение в C и также
участвуют в C. Из этого следует, что fatherp ¹ udef для всех p ¹ p0. Что T не содержит циклов, можно показать,
как в доказательстве Леммы 6.3.

В
корне дерева находится p0; обозначим через Tp множество
вершин в поддереве p. Ребра сети, не принадлежащие T, называются листовыми
ребрами (frond edges). В ¡ каждый
процесс p, по крайней мере, послал сообщения всем своим соседям, кроме родителя
fatherp, следовательно, каждое листовое ребро передавало в C
сообщения в обоих направлениях. Пусть fp – событие, в котором p
посылает сообщение своему родителю (если в C это происходит), а gp –
событие, в котором родитель p получает сообщение от p (если это происходит). С
помощью индукции по вершинам дерева можно показать, что

(1) C содержит
событие fp для любого p ¹ p0;

(2) для всех
s Î Tp существует
событие e Î Cs
такое, что e p gp.

Мы
рассмотрим следующие два случая.

p
– лист. p получил в C сообщение от своего родителя и от всех других соседей
(т.к. все остальные каналы – листовые). Таким образом, посылка <tok>
родителю p была возможна, и, т.к. ¡
– конечная конфигурация, это произошло. Tp содержит только p, и,
очевидно, fp p
gp.

p
– не лист. p получил в C сообщение от своего родителя и через все листовые
ребра. По индукции, C содержит fp¢
для каждой дочерней вершины p¢ вершины
p, и, т.к. ¡ – конечная
конфигурация, C также содержит gp¢.
Следовательно, посылка <tok> родителю p была возможна, и, т.к. ¡ – конечная конфигурация, это
произошло. Tp состоит из объединения Tp¢ по всем дочерним вершинам p и из
самого p. С помощью индукции можно показать, что в каждом процессе этого
множества существует событие, предшествующее gp.

Отсюда
следует, также, что p0 получил сообщение от каждого соседа и
выполнил событие decide, которому предшествуют события в каждом
процессе.

Остовное
дерево, которое строится в вычислении Алгоритма 6.5, иногда используют в
последовательно выполняемых алгоритмах. (Например, алгоритм Мерлина-Сегалла
(Merlin-Segall) для вычисления таблиц кратчайших маршрутов предполагает, что
изначально дано остовное дерево с корнем в v0; см. Подраздел 4.2.3.
Начальное остовное дерево может быть вычислено с использованием эхо-алгоритма).
В последней конфигурации алгоритма каждый процесс (кроме p0)
запомнил, какой сосед в дереве является его родителем, но не запомнил дочерних
вершин. В алгоритме одинаковые сообщения принимаются от родителя, через
листовые ребра, и от дочерних вершин. Если требуется знание дочерних вершин в
дереве, алгоритм может быть слегка изменен, так чтобы отправлять родителю
сообщения, отличные от остальных (в последней операции
отправления сообщения для не-инициаторов). Дочерними вершинами процесса тогда являются
те соседи, от которых были получены эти сообщения.

6.2.4  Алгоритм опроса

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

Теорема
6.18  Алгоритм опроса (Алгоритм 6.6) является волновым алгоритмом.

Доказательство.
Алгоритм пересылает по два сообщения через каждый канал, смежный с инициатором.
Каждый сосед инициатора отвечает только один раз на первоначальный опрос,
следовательно, инициатор получает N-1 ответ. Этого достаточно, чтобы принять
решение, следовательно, инициатор принимает решение и ему предшествует событие
в каждом процессе.

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

var 
recp         :  integer   init  0 ;      (* только для
инициатора *)

Для инициатора:

          begin  forall  q
Î Neighp  do 
send <tok>  to q ;

                      while 
recp < # Neighp  do

                                begin 
receive <tok> ;  recp := recp + 1  end
;

                      decide

          end ;

Для не-инициатора:

          begin  receive
<tok>  from q ;  send <tok>  to q   end

Алгоритм 6.6 Алгоритм опроса.

 

6.2.5  Фазовый алгоритм

В
этом разделе будет представлен фазовый алгоритм, который является
децентрализованным алгоритмом для сетей с произвольной топологией. Алгоритм дан
в [Tel91b, Раздел 4.2.3]. Алгоритм может использоваться как волновой для
ориентированных сетей.

Алгоритм
требует, чтобы процессам был известен диаметр сети, обозначенный в тексте
алгоритма как D. Алгоритм остается корректным (хотя и менее эффективным), если
процессы вместо D используют константу D¢ >
D. Таким образом, для применения алгоритма необязательно точно знать диаметр
сети; достаточно, если известна верхняя граница диаметра (например, N-1). Все
процессы должны использовать одну и ту же константу D¢. Пелег [Peleg; Pel90]  дополнил
алгоритм таким образом, чтобы диаметр вычислялся во время выполнения, но это расширение
требует уникальной идентификации.

Общий
случай. Алгоритм может использоваться в ориентированных сетях
произвольной топологии, где каналы могут передавать сообщения только в одном
направлении. В этом случае, соседи p являются соседями по входу (процессы,
которые могут посылать сообщения p) и соседями по выходу (процессы, которым
p может посылать сообщения). Соседи по входу p содержатся в множестве Inp,
а соседи по выходу – в множестве Outp.

В
фазовом алгоритме каждый процесс посылает ровно D сообщений каждому соседу по
выходу. Только после того, как i сообщений было получено от каждого соседа по
входу, (i+1)-ое сообщение посылается каждому соседу по выходу; см. алгоритм
6.7.

cons  D          
: integer       = диаметр сети ;

 var  
recp[q]    : 0..D           init  0,  для каждого  q Î Inp ;

                           
(* Количество сообщений, полученных от q *)

        
Sentp      : 0..D           init  0 ;

                           
(* Количество сообщений, посланных каждому соседу по выходу *)

 

begin   if 
p – инициатор  then

              begin   forall 
r Î Outp  do 
send <tok>  to r ;

                          Sentp
:= Sentp + 1 

              end
;

            while 
minq Recp[q] < D  do

                     begin 
receive  <tok>  (от соседа q0) ;

                                 Recp[q0]
:= Recp[q0] + 1 ;

                                 if 
minq Recp[q] ³
Sentp  and  Sentp < D  then

                                      begin 
forall  r Î Outp do 
send <tok>  to r ;

                                                  Sentp
:= Sentp + 1

                                      end

                     end
;

            decide

end            

Алгоритм 6.7 Фазовый алгоритм.

Действительно,
из текста алгоритма очевидно, что через каждый канал проходит не более D сообщений
(ниже показано, что через каждый канал проходит не менее D сообщений). Если
существует ребро pq, то fpq(i) – i-е событие, в котором p
передает сообщение q, а gpq(i) – i-е событие, в котором q
получает сообщение от p. Если канал между p и q удовлетворяет дисциплине FIFO,
эти события соответствуют друг другу и неравенство fpq(i) p gpq(i) 
выполняется. Каузальные отношения между  fpq(i)  и 
gpq(i)  сохраняются и в случае, если канал не является
FIFO, что доказывается в следующей лемме.

Лемма
6.19 Неравенство fpq(i) p gpq(i) 
выполняется, даже если канал не является каналом FIFO.

Доказательство.
Определим mh следующим образом: fpq(mh) –
событие отправления сообщения, соответствующее gpq(h),
т.е. в своем h-м событии получения q получает mh-е сообщение p. Из
определения каузальности  fpq(mh) p gpq(h).

Т.к.
каждое сообщение в C получают только один раз, все mh различны,
откуда следует, что хотя бы одно из чисел m1, …, mi
больше или равно i. Выберем j £
i так, чтобы mj ³ i. Тогда  fpq(i) p fpq(mj) p gpq(j) p gpq(i).

Теорема
6.20 Фазовый алгоритм (Алгоритм 6.7) является волновым алгоритмом.

Доказательство.
Т.к. каждый процесс посылает не более D сообщений по каждому каналу, алгоритм
завершается за конечное число шагов. Пусть ¡
– заключительная конфигурация вычисления C алгоритма, и предположим, что в C
существует, по крайней мере, один инициатор (их может быть больше).

Чтобы
продемонстрировать, что в ¡
каждый процесс принял решение, покажем сначала, что каждый процесс хотя бы один
раз послал сообщения. Т.к. в ¡ по
каналам не передается ни одно сообщение, для каждого канала qp  Recp[q]
= Sentpq. Также, т.к. каждый процесс посылает сообщения, как только
получит сообщение сам, Recp[q] > 0 Þ Sentp > 0. Из предположения, что
существует хотя бы один инициатор p0, для которого Sentp0 >
0, следует, что Sentp > 0 для каждого p.

Впоследствии 
будет показано, что каждый процесс принял решение. Пусть p – процесс с минимальным
значением переменной Sent в ¡,
т.е. для всех q  Sentq ³
Sentp в ¡. В
частности, это выполняется, если q – сосед по входу p, и из Recp[q] =
Sentq следует, что  minq Recp[q] ³ Sentp. Но отсюда следует,
что Sentp = D; иначе p послал бы дополнительные сообщения, когда он
получил последнее сообщение. Следовательно, Sentp = D для всех p, и
Recp[q] = D для всех qp, откуда действительно следует, что каждый
процесс принял решение.

Остается
показать, что каждому решению предшествует событие в каждом процессе. Если
P = p0, p1, …, pl (l £ D) – маршрут в сети, тогда, по Лемме
6.19,

 для 0 £ i < l и, по алгоритму,

для 0 £ i < l – 1.
Следовательно, . Т.к. диаметр
сети равен D, для любых q и p существует маршрут q = p0, p1,
…, pl = p  длины не более D. Таким образом, для любого q
существует l £ D и  сосед по
входу r процесса p, такие, что ; на
основании алгоритма, предшествует dp.

Алгоритм
пересылает D сообщений через каждый канал, что приводит в сложности сообщений,
равной |E|*D. Однако нужно заметить, что |E| обозначает количество направленных
каналов. Если алгоритм используется для неориентированной сети, каждый
канал считается за два направленных канала, и сложность сообщений равна 2|E|*D.

var  
recp            : 0..N – 1      init  0 ;

                           
(* Количество полученных сообщений *)

        
Sentp      : 0..1           init  0 ;

                           
(* Количество сообщений, посланных каждому соседу *)

 

begin   if 
p – инициатор  then

              begin   forall 
r Î Neighp  do 
send <tok>  to r ;

                          Sentp
:= Sentp + 1 

              end
;

            while 
Recp < # Neighp  do

                     begin 
receive  <tok> ;

                                 Recp
:= Recp + 1 ;

                                 if 
Sentp = 0  then

                                      begin 
forall  r Î Neighp
do  send <tok>  to r ;

                                                  Sentp
:= Sentp + 1

                                      end

                     end
;

            decide

end            

Алгоритм 6.8 Фазовый алгоритм для клики.

Фазовый
алгоритм для клики. Если сеть имеет топологию клика, ее диаметр равен 1; в
этом случае от каждого соседа должно быть получено ровно одно сообщение, и для
каждого процесса достаточно посчитать общее количество полученных сообщений
вместо того, чтобы считать сообщения от каждого соседа по входу отдельно; см.
Алгоритм 6.8. Сложность сообщений в этом случае равна N(N-1) и алгоритм использует
только O(log N) бит оперативной памяти.

6.2.6  Алгоритм Финна

Алгоритм
Финна [Fin79] – еще один волновой алгоритм, который можно использовать в
ориентированных сетях произвольной топологии. Он не требует того, чтобы диаметр
сети был известен заранее, но подразумевает наличие уникальных идентификаторов
процессов. В сообщениях передаются множества идентификаторов процессов, что
приводит к довольно высокой битовой сложности алгоритма.

Процесс
p содержит два множества идентификаторов процессов, Incp и NIncp.
Неформально говоря, Incp – это множество процессов q таких, что
событие в q предшествует последнему произошедшему событию в p, а NIncp
– множество процессов q таких, что для всех соседей r процесса q событие в r
предшествует последнему произошедшему событию в p. Эта зависимость
поддерживается следующим образом. Изначально Incp = {p}, а NIncp =
Æ. Каждый раз, когда одно из
множеств пополняется, процесс p посылает сообщение, включая в него Incp
и NIncp. Когда p получает сообщение, включающее множества Inc и
NInc, полученные идентификаторы включаются в версии этих множеств в процессе p.
Когда p получит сообщения от всех соседей по входу, p включается в NIncp.
Когда два множества становятся равны, p принимает решение; см. Алгоритм 6.9. Из
неформального смысла двух множеств следует, что для каждого процесса q такого,
что событие в q предшествует dp, выполняется следующее: для каждого
соседа r процесса q событие в r также предшествует dp, откуда
следует зависимость алгоритма.

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

Теорема
6.21  Алгоритм Финна (Алгоритм 6.9) является волновым алгоритмом.

Доказательство.
Заметим, что два множества, поддерживаемые каждым процессом, могут только
расширяться. Т.к. размер двух множеств в сумме составляет не менее 1 в первом
сообщении, посылаемом по каждому каналу, и не более 2N в последнем сообщении,
то общее количество сообщений ограничено 2N*|E|.

Пусть
C – вычисление, в котором существует хотя бы один инициатор, и пусть ¡ – заключительная конфигурация. Можно
показать, как в доказательстве Теоремы 6.20, что если процесс p отправил сообщения
хотя бы один раз (каждому соседу), а q – сосед p по выходу, то q тоже отправил
сообщения хотя бы один раз. Отсюда следует, что каждый процесс переслал хотя бы
одно сообщение (через каждый канал).

var    Incp       :
set of processes         init  {p} ;

             NIncp   :
set of processes         init  Æ
;

          recp[q] :
boolean  for q Î Inp  init 
false ;

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

begin   if 
p – инициатор  then

                 forall 
r Î Outp  do 
send <sets, Incp, NIncp>  to r ;

            while 
Incp ¹ NIncp 
do

                     begin   receive
<sets, Inc, NInc>  from q0 ;

                                 Incp
:= Incp È Inc ; NIncp
:= NIncp È NInc ;

                                 recp[q0]
:= true ;

                                 if 
"q Î
Inp : recp[q]  then  NIncp := NIncp
È {p} ;

                                 if
 Incp  или  NIncp  изменились  then

                                      forall 
r Î Outp  do 
send <sets, Incp, NIncp>  to r

                     end
;

            decide

end

Алгоритм 6.9 Алгоритм Финна.

Сейчас
мы покажем, что в ¡ каждый
процесс принял решение. Во-первых, если существует ребро pq, то Incp Í Incq в ¡. Действительно, после последнего
изменения Incp процесс p посылает сообщение <sets, Incp,
NIncp>, и после его получения в q выполняется Incq :=
Incq È Incp.
Из сильной связности сети следует, что Incp = Incq
для всех p и q. Т.к. выполняется p Î
Incp и каждое множество Inc содержит только идентификаторы
процессов, для каждого p  Incp = P.

Во-вторых,
подобным же образом может быть показано, что NIncp = Nincq
для любых p и q. Т.к. каждый процесс отправил хотя бы одно сообщение по каждому
каналу, для каждого процесса p выполняется: " q Î Inp : recp[q],
и следовательно, для каждого p выполняется: p Î NIncp. Множества NInc содержат только
идентификаторы процессов, откуда следует, что NIncp = P для каждого p. Из  Incp =
P и  NIncp = P следует, что Incp = NIncp,
следовательно, каждый процесс p в ¡
принял решение.

Теперь
нужно показать, что решению dp в процессе p предшествуют события в
каждом процессе. Для события e в процессе p обозначим через Inc(e)
(или, соответственно, NInc(e)) значение Incp (NIncp)
сразу после выполнения e (сравните с доказательством Теоремы 6.12). Следующие
два утверждения формализуют неформальные описания множеств в начале этого
раздела.

Утверждение
6.22  Если существует событие e Î
Cq : e p
f, то q Î Inc(f).

Доказательство.
Как в доказательстве Теоремы 6.12, можно показать, что e p f Þ
Inc(e) Í Inc(f),
а при e Î Cq Þ q Î
Inc(e), что и требовалось доказать.

Утверждение
6.23  Если q Î
NInc(f), тогда для всех  r Î Inq существует событие e Î Cr : e p f.

Доказательство.
Пусть aq – внутреннее событие q, в котором впервые в q выполняется
присваивание NIncq := NIncq È {q}. Событие aq – единственное событие с
q Î NInc(aq),
которому не предшествует никакое другое событие a¢,
удовлетворяющее условию q Î
NInc(a¢); таким образом, q Î NInc(f) Þ aq p f.

Из
алгоритма следует, что для любого r Î
Inq существует событие e Î
Cr, предшествующее aq. Отсюда следует результат.

Процесс
p принимает решение только когда Incp = NIncp; можно
записать, что Inc(dp) = NInc(dp). В
этом случае

(1) p Î Inc(dp)
; и

(2) из
q Î Inc(dp)
следует, что q Î NInc(dp),
откуда следует, что Inq Í
Inc(dp).

Из сильной связности сети следует требуемый результат: Inc(dp) =
P.

 

6.3  Алгоритмы обхода

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

Определение
6.24  Алгоритмом обхода называется алгоритм, обладающий следующими тремя
свойствами.

(1) В
каждом вычислении один инициатор, который начинает выполнение алгоритма,
посылая ровно одно сообщение.

(2) Процесс,
получая сообщение, либо посылает одно сообщение дальше, либо принимает решение.

Из
первых двух свойств следует, что в каждом конечном вычислении решение принимает
ровно один процесс. Говорят, что алгоритм завершается в этом процессе.

(3) Алгоритм
завершается в инициаторе и к тому времени, когда это происходит, каждый процесс
посылает сообщение хотя бы один раз.

В
каждой достижимой конфигурации алгоритма обхода либо передается ровно одно
сообщение, либо ровно один процесс получил сообщение и еще не послал ответное
сообщение. С более абстрактной точки зрения, сообщения в вычислении, взятые
вместе, можно рассматривать как единый объект (маркер), который
передается от процесса к процессу и, таким образом, «посещает» все процессы. В
Разделе 7.4 алгоритмы обхода используются для построения алгоритмов выбора и
для этого важно знать не только общее количество переходов маркера в одной
волне, но и сколько переходов необходимо для того, чтобы посетить первые x  процессов.

Определение
6.25  Алгоритм называется алгоритмом f-обхода (для класса сетей),
если

(1) он
является алгоритмом обхода (для этого класса); и

(2) в
каждом вычислении после f(x) переходов маркера посещено не менее min (N,
x+1) процессов.

Кольцевой
алгоритм (Алгоритм 6.2) является алгоритмом обхода, и, поскольку x+1 процесс
получил маркер после x шагов (для x < N), а все процессы получат его
после N шагов, это алгоритм x-обхода для кольцевой сети.

6.3.1  Обход клик

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

var    recp        :
integer      init  0 ; (* только для инициатора *)

Для инициатора:

          (*
обозначим Neighp = {q1, q2, .., qN-1}
*)

          begin   while
 recp < # Neighp  do

                               begin 
send <tok>  to qrecp+1 ;

                                        receive
<tok>;  recp := recp + 1

                               end
;

                     decide

          end

Для
не-инициатора:

          begin 
receive <tok>  from q ;  send <tok>  to q  end

Алгоритм 6.10 Последовательный алгоритм опроса.

Теорема
6.26  Последовательный алгоритм опроса (Алгоритм 6.10) является алгоритмом
2x-обхода для клик.

Доказательство. 
Легко заметить, что к тому времени, когда алгоритм завершается, каждый процесс
послал инициатору ответ. (2x-1)-е сообщение – это опрос для qx, а
(2x)-е – это его ответ. Следовательно, когда было передано 2x сообщений, был
посещен x+1 процесс p, q1, …, qx.

6.3.2  Обход торов

Тором
n´n называется граф G =
(V,E), где

            V =
Zn ´ Zn
= { (i, j) : 0 £ i, j
< n}  и

            E =
{(i, j)(i¢, j¢) : (i = i¢  &  j = j¢ ±1) Ú
(i = i¢ ±1  &  j = j¢) };

см. Раздел
B.2.4. (Сложение и вычитание здесь по модулю n.) Предполагается, что тор
обладает чувством направления (см. Раздел B.3), т.е. в вершине (i, j) канал
к (i, j+1) имеет метку Up, канал к (i, j-1) – метку Down, канал к
(i+1, j) – метку Right, и канал к (i-1, j) – метку Left.
Координатная пара (i, j) удобна для определения топологии сети и ее
чувства направления, но мы предполагаем, что процессы не знают этих координат;
топологическое знание ограничено метками каналов.

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

          send
<num, 1>  to Up

Для
каждого процесса при получении маркера <num,k>:

          begin   if 
k=n2  then  decide

                     else 
if n|k then  send <num,k+1> to Up

                                      else
send <num,k+1> to Right

          end

Алгоритм 6.11 Алгоритм обхода для торов.

Тор
является Гамильтоновым графом, т.е. в торе (произвольного размера) существует
Гамильтонов цикл и маркер передается по циклу с использованием Алгоритма 6.11.
После k-го перехода маркера он пересылается вверх, если n|k (k делится на n),
иначе он передается направо.

Теорема
6.27  Алгоритм для тора (Алгоритм 6.11) является алгоритмом x-обхода
для торов.

Доказательство.
Как легко заметить из алгоритма, решение принимается после того, как маркер был
передан n2 раз. Если маркер переходит от процесса p к процессу q с
помощью U переходов вверх и R переходов вправо, то p = q тогда и только
тогда, когда (n|U & n|R). Обозначим через p0 инициатор, а через
pk – процесс, который получает маркер <num, k>.

Из
n2 переходов маркера n – переходы вверх, а оставшиеся n2-n
– переходы вправо. Т.к. и n, и n2-n кратны n, то pn2 =
p0, следовательно, алгоритм завершается в инициаторе.

Далее
будет показано, что все процессы с p0 по pn2 -1
различны; т.к. всего n2 процессов, то  отсюда следует, что каждый
процесс был пройден. Предположим, что pa =
pb для 0 £
a < b < n2. Между pa и pb
маркер сделал несколько переходов вверх и вправо, и т.к. pa = pb, количество
переходов кратно n. Изучив алгоритм, можно увидеть, что отсюда следует, что

#
{k : a £ k < b  &  n|k} 
кратно n, и

#
{k : a £ k < b  &  n не
|k}  кратно n.

Размеры двух
множеств в сумме составляют b-a, откуда следует, что n|(b-a). Обозначим (b-a) =
l*n, тогда множество {k: a £
k < b} содержит l кратных n. Отсюда следует, что n|l, а значит n2|(b-a),
что приводит к противоречию.

Т.к.
все процессы с p0 по pn2 -1 различны, после x
переходов маркера будет посещен x+1 процесс.

6.3.3  Обход гиперкубов

N-мерным
гиперкубом называется граф G = (V,E), где

            V
= { (b0,…,bn-1) : bi = 0, 1} и

            E
= { (b0,…,bn-1),(c0,…,cn-1) : b
и c отличаются на 1 бит};

см. Подраздел
B.2.5. Предполагается, что гиперкуб обладает чувством направления (см. Раздел
B.3), т.е. канал между вершинами b и c, где b и c различаются битом с номером i, 
помечается «i» в обеих вершинах. Предполагается, что метки вершин не известны
процессам; их топологическое знание ограничено метками каналов.

Как
и тор, гиперкуб является Гамильтоновым графом, и Гамильтонов цикл обходится с
использованием Алгоритма 6.12. Доказательство корректности алгоритма похоже на
доказательство для Алгоритма 6.11.

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

          send
<num, 1>  по каналу  n -1

Для
каждого процесса при получении маркера <num,k>:

          begin   if 
k=2n  then  decide

                     else 
begin  пусть l – наибольший номер : 2l|k ;

                                        send
<num,k+1>  по каналу l

                               end                      

          end

Алгоритм 6.12 Алгоритм обхода для гиперкубов.

 

Теорема
6.28  Алгоритм для гиперкуба (Алгоритм 6.12) является алгоритмом x-обхода
для гиперкуба.

Доказательство. 
Из алгоритма видно, что решение принимается после 2n пересылок
маркера. Пусть p0 – инициатор, а pk – процесс, который
получает маркер <num,k>. Для любого k < 2n,
обозначения pk и pk+1 отличаются на 1 бит, индекс
которого обозначим как l(k), удовлетворяющий следующему условию:

Т.к.
для любого i < n существует равное количество k Î {0, …, 2n} с l(k) =
i, то p0 = p2n и решение принимается в инициаторе.
Аналогично доказательству Теоремы 6.27, можно показать, что из pa =
pb следует, что 2n|(b-a), откуда следует, что все p0,
…, p2n-1
различны.

Из
всего этого следует, что, когда происходит завершение, все процессы пройдены, и
после x переходов маркера будет посещен x+1 процесс.

6.3.4  Обход связных сетей

Алгоритм
обхода для произвольных связных сетей был дан Тарри в 1895 [Tarry; T1895].
Алгоритм сформулирован в следующих двух правилах; см. Алгоритм 6.13.

R1.
Процесс никогда не передает маркер дважды по одному и тому же каналу.

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 <tok>  to q ;

          end

Для каждого процесса при
получении <tok> от 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 <tok>  to q

                                            
end

                                    else 
begin  usedp[fatherp] := true ;

                                                      send
<tok>  to fatherp

                                             end

          end

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

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

Доказательство.
Т.к. маркер передается не более одного раза в обоих направлениях через
каждый канал, всего он передается не более 2|E| раз до завершения алгоритма.
Т.к. каждый процесс передает маркер через каждый канал не более одного раза, то
каждый процесс получает маркер через каждый канал не более одного раза. Каждый
раз, когда маркер захватывается не-инициатором p, получается, что процесс p
получил маркер на один раз больше, чем послал его. Отсюда следует, что
количество каналов, инцидентных p, превышает количество каналов, использованных
p, по крайней мере, на 1. Таким образом, p не принимает решение, а передает
маркер дальше. Следовательно, решение принимается в инициаторе.

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

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

(2) Для
каждого посещаемого процесса p все каналы, инцидентные p были
пройдены один раз в каждом направлении. Предположив, что это не так,
выберем в качестве p первый встретившийся процесс, для которого это не
выполняется, и заметим, что из пункта (1) p не является инициатором. Из выбора
p, все каналы, инцидентные fatherp были пройдены один раз в обоих
направлениях, откуда следует, что p переслал маркер своему родителю.
Следовательно, p использовал все инцидентные каналы, чтобы переслать маркер;
но, т.к. маркер в конце остается в инициаторе, p получил маркер ровно столько
же раз, сколько отправил его, т.е. p получил маркер по одному разу через каждый
инцидентный канал. Мы пришли к противоречию.

(3) Все
процессы были посещены и каждый канал был пройден по одному разу в обоих
направлениях. Если есть непосещенные процессы, то существуют соседи 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 <tok>  to q ;

          end

Для каждого процесса при
получении <tok> от 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 <tok>  to q

                                            
end

                                    else 
begin  usedp[fatherp] := true ;

                                                      send
<tok>  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 Алгоритмы поиска в глубину за
линейное время

Причина
высокой временной сложности классического алгоритма поиска в глубину состоит в
том, что все ребра, как принадлежащие дереву, так и листовые, обходятся
последовательно. Сообщение-маркер <tok> проходит по всем листовым
ребрам и немедленно возвращается обратно, как показано в доказательстве Теоремы
6.33. Все решения с меньшей временной сложностью основаны на том, что маркер
проходит только по ребрам дерева. Очевидно, на это потребуется линейное время,
т.к. существует только N-1 ребро дерева.

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

Когда
процесс p впервые посещается маркером (для инициатора это происходит в начале
алгоритма), p сообщает об этом всем соседям r, кроме его родителя, посылая
сообщения <vis>. Передача маркера откладывается, пока p не получит
сообщения <ack> от всех соседей. При этом гарантируется, что
каждый сосед r процесса p в момент, когда p передает маркер, знает, что p был
посещен. Когда позже маркер прибывает в r, r не передаст маркер p, если только
p не его родитель; см. Алгоритм 6.15.

Из-за
передачи сообщений <vis> в большинстве случаев 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 единиц времени. В каждой вершине маркер простаивает перед тем,
как быть переданным, не более одного раза из-за обмена сообщениями <vis>/<ack>,
что приводит к задержке не более чем на 2 единицы времени в каждой вершине.

Каждое
листовое ребро передает два сообщения <vis> и два сообщения <ack>.
Каждое ребро в дереве передает два сообщения <tok>, одно <vis>
(посылаемое от родителя потомку), и одно <ack> (от потомка родителю).
Следовательно, передается 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 <vis>  to r ;

                     forall  r
Î Neighp  do 
receive <ack>  from r ;

                     usedp[q]
:= true ;  send <tok>  to q ;

          end

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

          begin   if  fatherp
= udef  then 

                          begin 
fatherp := q0 ;

                                      forall 
r Î Neighp\
{fatherp}  do  send <vis>  to r ;

                                      forall 
r Î Neighp\
{fatherp}  do  receive <ack>  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 <tok>  to q

                                            
end

                                    else 
begin  usedp[fatherp] := true ;

                                                      send
<tok>  to fatherp

                                             end

          end

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

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

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

Передачу
сообщения <vis> соседу, которому процесс передает маркер, можно
опустить. Это усовершенствование (не выполняемое в Алгоритме 6.15) сберегает по
два сообщения для каждого ребра дерева и, следовательно, уменьшает сложность сообщений
на 2N-2 сообщения.

Решение
Сайдона.  Алгоритм Сайдона [Cidon; Cid88] улучшает временную сложность
алгоритма Авербаха, не посылая сообщения <ack>. В модификации
Сайдона маркер передается немедленно, т.е. без задержки на 2 единицы времени,
внесенной в алгоритм Авербаха ожиданием подтверждения. Этот же алгоритм был
предложен Лакшмананом и др. [Lakshmanan; LMT87]. В алгоритме Сайдона может
возникнуть следующая ситуация. Процесс p получил маркер и послал сообщение <vis>
своему соседу r. Маркер позже попадает в r, но в момент, когда r получает
маркер, сообщение <vis> процесса p еще не достигло r. В этом
случае r может передать маркер p, фактически посылая его через листовое ребро.
(Заметим, что сообщения <ack> в алгоритме Авербаха предотвращают
возникновение такой ситуации.)

Чтобы
обойти эту ситуацию процесс p запоминает (в переменной mrsp), какому
соседу он переслал маркер в последний раз. Когда маркер проходит только по
ребрам дерева, p получает его в следующий раз от того же соседа mrsp.
В ситуации, описанной выше, p получает сообщение <tok> от другого
соседа, а именно, от r; в этом случае маркер игнорируется, но p помечает
ребро rp, как пройденное, как если бы от r было получено сообщение <vis>.
Процесс r получает сообщение <vis> от p после пересылки маркера p,
т.е. r получает сообщение <vis> от соседа mrsr. В этом
случае r действует так, как если бы он еще не послал маркер p; r выбирает
следующего соседа и передает маркер; см. Алгоритм 6.16/6.17.

Теорема
6.35  Алгоритм Сайдона (Алгоритм 6.16/6.17) вычисляет DFS-дерево
за 2N-2 единиц времени, используя 4|E| сообщений.

Доказательство.
 Маршрут маркера подобен маршруту в Алгоритме 6.14. Прохождение по листовым
ребрам либо пропускается (как в Алгоритме 6.15), либо в ответ на маркер через
листовое ребро посылается сообщение <vis>. В последнем случае,
процесс, получая сообщение <vis>, продолжает передавать маркер,
как если бы маркер был возвращен через листовое ребро немедленно.

Время
между двумя успешными передачами маркера по дереву ограничено одной единицей
времени. Если маркер послали по ребру дерева процессу p в момент времени t, то
в момент t все сообщения <vis> ранее посещенных соседей q процесса
p были посланы, и, следовательно, эти сообщения прибудут не позднее момента
времени t+1. Итак, хотя p мог несколько раз послать маркер по листовым ребрам
до t+1, не позднее t+1  p восстановился после всех этих ошибок и передал маркер
по ребру, принадлежащему  дереву. Т.к. должны быть пройдены 2N-2 ребра дерева,
алгоритм завершается за 2N-2 единиц времени.

Через
каждый канал передается не более двух сообщений <vis> и двух <tok>,
откуда граница сложности сообщений равна 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 <vis>  to r ;

                     usedp[q]
:= true ;  mrsp := q ;  send <tok>  to q ;

          end

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

          begin   usedp[q0]
:= true ; 

                     if  q0
= mrsp  then  (* интерпретировать, как <tok> *)

                          передать
сообщение <tok> как при получении <tok>

          end

Алгоритм 6.16 Алгоритм поиска в глубину Сайдона (Часть 1).

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

          begin   if mrsp
¹ udef  and  mrsp
¹ q0

                        (* это
листовое ребро, интерпретируем как сообщение <vis>*)

                        then
usedp[q0] := true

                        else
(* действовать, как в предыдущем алгоритме *)

                            begin 
if  fatherp = udef  then 

                                           begin 
fatherp := q0 ;

                                                     forall 
r Î Neighp\
{fatherp} 

                                                           do 
send <vis>  to 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 ;  mrsp := q ;

                                                                              send
<tok>  to q

                                                                   
end

                                                         else 
begin  usedp[fatherp] := true ;

                                                                            send
<tok>  to fatherp

                                                                  end

                            end

          end

Алгоритм 6.17 Алгоритм поиска в глубину Сайдона (Часть 2).

Во
многих случаях этот алгоритм будет пересылать меньше сообщений, чем алгоритм
Авербаха. Оценка количества сообщений в алгоритме Сайдона предполагает
наихудший случай, а именно, когда маркер пересылается через каждое листовое
ребро в обоих направлениях. Можно ожидать, что сообщения <vis>
помогут избежать многих нежелательных пересылок, тогда через каждый канал будет
передано только два или три сообщения.

Сайдон
замечает, что хотя алгоритм может передать маркер в уже посещенную вершину, он
обладает лучшей временной сложностью (и сложностью сообщений), чем Алгоритм
6.15, который предотвращает такие нежелательные передачи. Это означает, что на
восстановление после ненужных действий может быть затрачено меньше времени и
сообщений, чем на их предотвращение. Сайдон оставляет открытым вопрос о том,
существует ли DFS-алгоритм, который достигает сложности сообщений классического
алгоритма, т.е. 2|E|, и который затрачивает O(N) единиц времени.

6.4.3  Поиск в глубину со
знанием соседей

Если
процессам известны идентификаторы их соседей, проход листовых ребер можно
предотвратить, включив в маркер список посещенных процессов. Процесс p, получая
маркер с включенным в него списком L, не передает маркер процессам из L.
Переменная usedp[q] не нужна, т.к. если p ранее передал маркер q, то
q Î L; см. Алгоритм 6.18.

Теорема
6.36  DFS-алгоритм со знанием соседей является алгоритмом обхода
и вычисляет дерево поиска в глубину, используя 2N-2 сообщений за 2N-2
единиц времени.

У
этого алгоритма высокая битовая сложность; если w – количество бит, необходимых
для представления одного идентификатора, список L может занять до Nw бит; см.
Упражнение 6.14.

var  fatherp        :
process     init udef ;

      

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

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

                     send <tlist,
{p}>  to q

          end

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

          begin   if  fatherp
= udef  then  fatherp := q0 ;

                     if  $q Î
Neighp \ L

                          then 
begin  выбор  q Î Neighp
\ L ;

                                             send
< tlist, LÈ{p} > 
to q

                                    end

                          else 
if  p – инициатор

                                      then
 decide

                                      else 
send < tlist, LÈ{p}
> to fatherp

          end

Алгоритм 6.18 Алгоритм поиска в глубину со знанием соседей.

 6.5  Остальные вопросы

6.5.1  Обзор волновых
алгоритмов

В
Таблице 6.19 дан список волновых алгоритмов, рассмотренных в этой главе. В
столбце «Номер» дана нумерация алгоритмов в главе; в столбце «C/D» отмечено,
является ли алгоритм централизованным (C) или децентрализованным (D); столбец
«T» определяет, является ли алгоритм алгоритмом обхода; в столбце «Сообщения»
дана сложность сообщений; в столбце «Время» дана временная сложность. В этих
столбцах N – количество процессов, |E| – количество каналов, D – диаметр сети
(в переходах).

 

Алгоритм
Номер
Топология
C/D
T
Сообщения
Время

Раздел 6.2:  Общие алгоритмы

Кольцевой
6.2
кольцо
C
да
N
N

Древовидный
6.3
дерево
D
нет
N
O(D)

Эхо-алгоритм
6.5
произвольная
C
нет
2|E|
O(N)

Алгоритм опроса
6.6
клика
C
нет
2N-2
2

Фазовый
6.7
произвольная
D
нет
2D|E|
2D

Фазовый на кликах
6.8
клика
D
нет
N(N-1)
2

Финна
6.9
произвольная
D
нет
£4N|E|
O(D)

Раздел 6.3:  Алгоритмы обхода

Последовательный
опрос
6.10
клика
C
да
2N-2
2N-2

Для торов
6.11
тор
C
да
N
N

Для гиперкубов
6.12
гиперкуб
C
да
N
N

Тарри
6.13
произвольная
C
да
2|E|
2|E|

Раздел 6.4:  Алгоритмы поиска в глубину

Классический
6.14
произвольная
C
да
2|E|
2|E|

Авербаха
6.15
произвольная
C
нет
4|E|
4N-2

Сайдона
6.16/6.17
произвольная
C
нет
4|E|
2N-2

Со знанием соседей
6.18
произвольная
C
да
2N-2
2N-2

Замечание: фазовый алгоритм (6.7) и алгоритм Финна (6.9)
подходят для ориентированных сетей.

Таблица 6.19  Волновые алгоритмы этой главы.

Сложность
распространения волн в сетях большинства топологий значительно зависит от того,
централизованный алгоритм или нет. В Таблице 6.20 приведена сложность сообщений
централизованных и децентрализованных волновых алгоритмов для колец,
произвольных сетей и деревьев. Таким же образом можно проанализировать
зависимость сложности от других параметров, таких как знание соседей или чувство
направления (Раздел B.3).

Топология
C/D
Сложность
Ссылка

Кольцо
C
N
Алгоритм 6.2

D
O(N logN)
Алгоритм 7.7

Произвольная
C
2|E|
Алгоритм 6.5

D
O(N logN + |E|)
Раздел 7.3

Дерево
C
2(N-1)
Алгоритм 6.5

D
O(N)
Алгоритм 6.3

Таблица 6.20  Влияние централизации на сложность сообщений.

6.5.2  Вычисление сумм

В
Подразделе 6.1.5 было показано, что за одну волну можно вычислить инфимум по
входам всех процессов. Вычисление инфимума может быть использовано для
вычисления коммутативного, ассоциативного и идемпотентного оператора,
обобщенного на входы, такого как минимум, максимум, и др. (см. Заключение
6.14). Большое количество функций не вычислимо таким образом, среди них – сумма
по всем входам, т.к. оператор суммирования не идемпотентен. Суммирование входов
может быть использовано для подсчета процессов с определенным свойством (путем
присваивания входу 1, если процесс обладает свойством, и 0 в противном случае),
и результаты этого подраздела могут быть распространены на другие операторы,
являющиеся коммутативными и ассоциативными, такие как произведение целых чисел
или объединение мультимножеств.

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

Невозможность
существования общего метода. Невозможно дать общий метод вычисления сумм с
использованием произвольного волнового алгоритма, подобного методу,
использованному в Теореме 6.12 для вычисления инфимумов. Это может быть
показано следующим образом. Существует волновой алгоритм для класса сетей,
включающего все неориентированные анонимные (anonymous) сети диаметра два, а
именно, фазовый алгоритм (с параметром D=2). Не существует алгоритма, который
может вычислить сумму по всем входам, и который является правильным для всех
неориентированных анонимных (anonymous) сетей диаметра два. Этот класс сетей
включает две сети, изображенные на Рис.6.21. Если предположить, что каждый
процесс имеет вход 1, ответ будет 6 для левой сети и 8 – для правой.
Воспользовавшись технологией, представленной в Главе 9, можно показать, что
любой алгоритм даст для обеих сетей один и тот же результат, следовательно,
будет работать неправильно. Детальное доказательство оставлено читателю в Упражнении
9.7.

Рис.6.21  Две сети диаметра два и степени три.

Вычисление
сумм с помощью алгоритма обхода. Если A – алгоритм обхода, сумма по всем
входам может быть вычислена следующим образом. Процесс p содержит переменную jp,
инициализированную значением входа p. Маркер содержит дополнительное поле s.
Всякий раз, когда p передает маркер, p выполняет следующее:

                     s
:= s + jp ;  jp := 0

 и затем можно
показать, что в любое время для каждого ранее пройденного процесса p jp =
0 и s равно сумме входов всех пройденных процессов. Следовательно, когда
алгоритм завершается, s равно сумме по всем входам.

Вычисление
суммы с использованием остовного дерева. Некоторые волновые алгоритмы предоставляют
для каждого события принятия решения dp в процессе p остовное дерево
с корнем в p, по которому сообщения передаются по направлению к p. Фактически,
каждое вычисление любого волнового алгоритма содержит такие остовные деревья.
Однако, может возникнуть ситуация, когда процесс q посылает несколько сообщений
и не знает, какие из его исходящих ребер принадлежат к такому дереву. Если
процессы знают, какое исходящее ребро является их родителем в таком дереве,
дерево можно использовать для вычисления сумм. Каждый процесс посылает своему
родителю в дереве сумму всех входов его поддерева.

Этот
принцип может быть применен для древовидного алгоритма, эхо-алгоритма и
фазового алгоритма для клик. Древовидный алгоритм легко может быть изменен так,
чтобы включать сумму входов Tpq в сообщение, посылаемое от p к q.
Процесс, который принимает решение, вычисляет окончательный результат,
складывая величины из двух сообщений, которые встречаются на одном ребре.
Фазовый алгоритм изменяется так, чтобы в каждом сообщении от q к p пересылался
вход q. Процесс p складывает все полученные величины и свой собственный вход, и
результат является правильным ответом, когда p принимает решение. В
эхо-алгоритме входы могут суммироваться с использованием остовного дерева T,
построенного явным образом во время вычисления; см. Упражнение 6.15.

Вычисление
суммы с использованием идентификации. Предположим, что каждый процесс имеет
уникальный идентификатор. Сумма по всем входам может быть вычислена следующим
образом. Каждый процесс помечает свой вход идентификатором, формируя пару (p, jp);
заметим, что никакие два процесса не формируют одинаковые пары. Алгоритм
гарантирует, что, когда процесс принимает решение, он знает каждый отдельный
вход; S = {(p, jp): p Î
P} – объединение по всем p множеств Sp =
{(p, jp)}, которое может быть вычислено за одну волну. Требуемый
результат вычисляется с помощью локальных операций на этом множестве.

Это
решение требует доступности уникальных идентификаторов для каждого процесса,
что значительно увеличивает битовую сложность. Каждое сообщение волнового
алгоритма включает в себя подмножество S, которое занимает N*w бит, если для
представления идентификатора и входа требуется w бит; см. Упражнение 6.16.

6.5.3  Альтернативные
определения временной сложности

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

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

Определение
6.37 Единичная сложность алгоритма (one-time complexity) – это
максимальное время вычисления алгоритма при следующих предположениях.

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

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

Сравним
это определение с Определением 6.31 и заметим, что предположение O1 совпадает с
T1. Т.к. время передачи сообщения, принятое в T2, меньше или равно  времени,
принятому в O2, можно подумать, что единичная сложность всегда больше
или равна временной сложности. Далее можно подумать, что каждое вычисление при
предположении T2 выполняется не дольше, чем при O2, и, следовательно, вычисление
с максимальным временем также займет при T2 не больше
времени, чем при O2. Упущение этого аргумента в том,
что отклонения во времени передачи сообщения, допустимые при T2, порождают
большой класс возможных вычислений, включая вычисления с плохим временем. Это
иллюстрируется ниже для эхо-алгоритма.

Фактически,
верно обратное: временная сложность алгоритма больше или равна единичной сложности
этого алгоритма. Любое вычисление, допустимое при предположениях O1 и O2, также
допустимо при T1 и T2 и занимает при этом такое же количество времени.
Следовательно, наихудшее поведение алгоритма при O1 и O2 включено в Определение
6.31 и является нижней границей временной сложности.

Теорема
6.38 Единичная сложность эхо-алгоритма равна O(D). Временная
сложность эхо-алгоритма равна Q(N),
даже в сетях с диаметром 1.

Доказательство.
Для анализа единичной сложности сделаем предположения O1 и O2. Процесс на
расстоянии d переходов от инициатора получает первое сообщение <tok>
ровно через d единиц времени после начала вычисления и имеет глубину d в
возникающем в результате дереве T. (Это можно доказать индукцией по d.) Пусть DT
– глубина T; тогда DT £
D и процесс глубины d в T посылает сообщение <tok> своему родителю
не позднее (2DT + 1) – d единиц времени после начала
вычисления. (Это можно показать обратной индукцией по d.) Отсюда следует, что
инициатор принимает решение не позднее 2DT + 1 единиц времени
после начала вычисления.

Для
анализа временной сложности сделаем предположения T1 и T2. Процесс на
расстоянии d переходов от инициатора получает первое сообщение <tok>
не позднее d единиц времени после начала вычисления. (Это можно доказать
индукцией по d.) Предположим, что остовное дерево построено через F единиц
времени после начала вычисления, тогда F £
D. В этом случае глубина остовного дерева DT необязательно
ограничена диаметром (как будет показано в вычислении ниже), но т.к. всего N
процессов, глубина ограничена N-1. Процесс глубины d в T посылает сообщение
<tok> своему родителю не позднее (F+1)+(DT-d) единиц
времени после начала вычисления. (Это можно показать обратной индукцией по d.)
Отсюда следует, что инициатор принимает решение не позднее (F+1)+DT
единиц времени после начала вычисления, т.е. O(N).

Чтобы
показать, что W(N) – нижняя
граница временной сложности, построим на клике из N процессов вычисление,
которое затрачивает время N. Зафиксируем в клике остовное дерево глубины N-1
(на самом деле, линейную цепочку вершин). Предположим, что все сообщения <tok>,
посланные вниз по ребрам дерева, будут получены спустя 1/N единиц времени после
их отправления, а сообщения <tok> через листовые ребра будут
получены спустя одну единицу времени. Эти задержки допустимы, согласно
предположению T2, и в этом вычислении дерево полностью формируется в течение
одной единицы времени, но имеет глубину N-1. Допустим теперь, что все
сообщения, посылаемые вверх по ребрам дерева также испытывают задержку в одну
единицу времени; в этом случае решение принимается ровно через N единиц времени
с начала вычисления.

Можно
спорить о том, какое из двух определений предпочтительнее при обсуждении
сложности распределенного алгоритма. Недостаток единичной сложности в том, что
некоторые вычисления не учитываются, хотя они и допускаются алгоритмом. Среди
игнорируемых вычислений могут быть такие, которые потребляют очень много
времени. Предположения в Определении 6.31 не исключают ни одного вычисления;
определение только устанавливает меру времени для каждого вычисления.
Недостаток временной сложности в том, что результат определен вычислениями (как
в доказательстве Теоремы 6.38), что хотя и возможно, но считается крайне
маловероятным. Действительно, в этом вычислении одно сообщение «обгоняется»
цепочкой из N-1 последовательно передаваемого сообщения.

В
качестве компромисса между двумя определениями можно рассмотреть a-временную сложность, которая
определяется согласно предположению, что задержка каждого сообщения – величина
между a и 1 (a – константа £1).
К сожалению, этот компромисс обладает недостатками обоих определений. Читатель
может попытаться показать, что a-временная
сложность эхо-алгоритма равна O(min(N,D/a)).

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

Определение,
основанное на цепочках сообщений. Затраты времени на распределенное вычисление
могут быть определены с использованием структурных свойств вычисления, а не
идеализированных временных предположений. Пусть C – вычисление.

Определение
6.39  Цепочка сообщений в C – это последовательность сообщений m1,
m2, …, mk такая, что для любого i  (0 £ i £
k) получение mi каузально предшествует отправлению mi+1.

Цепочечная
сложность распределенного алгоритма (chain-time complexity) – это длина самой
длинной цепочки сообщений во всех вычислениях алгоритма.

Это
определение, как и Определение 6.31, рассматривает всевозможные
выполнения алгоритма для определения его временной сложности, но определяет
другую меру сложности для вычислений. Рассмотрим ситуацию (происходящую в
вычислении, определенном в доказательстве теоремы 6.38), когда одно сообщение
«обгоняется» цепочкой из k сообщений. Временная сложность этого (под)вычисления
равна 1, в то время, как цепочечная сложность того же самого (под)вычисления
равна k. В системах, где гарантируется существование верхней границы задержек
сообщений (как предполагается в определении временной сложности), временная
сложность является правильным выбором. В системах, где большинство сообщений
доставляется со «средней» задержкой, но небольшая часть сообщений может
испытывать гораздо большую задержку, лучше выбрать цепочечную сложность.

Упражнения к  Главе 6

Раздел 6.1

Упражнение
6.1  Приведите пример PIF-алгоритма для систем с синхронной
передачей сообщений, который не позволяет вычислять функцию инфимума (см.
Теоремы 6.7 и 6.12). Пример может подходить только для конкретной топологии.

Упражнение
6.2  В частичном порядке (X,
£) элемент b называется дном, если для всех c Î X, b £ c.

В
доказательстве Теоремы 6.11 используется то, что частичный порядок (X,£) не содержит дна. Где именно?

Можете
ли вы привести алгоритм, который вычисляет функцию инфимума в частичном порядке
с дном и не является волновым алгоритмом?

Упражнение
6.3  Приведите два частичных порядка на натуральных числах, для которых
функция инфимума является (1) наибольшим общим делителем, и (2) наименьшим
общим кратным (the least common ancestor).

Приведите
частичные порядки на наборах подмножеств области U, для которых функция
инфимума является (1) пересечением множеств, и (2) объединением множеств.

Упражнение
6.4  Докажите теорему об инфимуме (Теорему 6.13).

Раздел 6.2

Упражнение
6.5  Покажите, что в каждом вычислении древовидного алгоритма (Алгоритм
6.3) решение принимают ровно два процесса.

Упражнение
6.6  Используя эхо-алгоритм (Алгоритм 6.5), составьте алгоритм, который
вычисляет префиксную схему маркировки (см. Подраздел 4.4.3) для произвольной
сети с использованием 2|E| сообщений и O(N) единиц времени.

Можете
ли вы привести алгоритм, вычисляющий схему маркировки за время O(D) ?
(D – диаметр сети.)   

Упражнение
6.7  Покажите, что соотношение в Лемме 6.19 выполняется, если
сообщение потерялось в канале pq, но не выполняется, если сообщения
могут дублироваться. Какой шаг доказательства не действует, если сообщения
могут дублироваться?

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

Каковы
сложность сообщений, временная и битовая сложность вашего алгоритма?

Упражнение
6.9  Предположим, вы хотите использовать волновой алгоритм в сети, где
может произойти дублирование сообщений.

(1) Какие
изменения должны быть сделаны в эхо-алгоритме?

(2)  Какие
изменения должны быть сделаны в алгоритме Финна?

Раздел 6.3

Упражнение
6.10  Полный двудольный граф – это граф G = (V,E), где V =
V1 È V2 
при V1 Ç
V2 = Æ  и  E =
V1 ´ V2.

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

Упражнение
6.11  Докажите или опровергните: Обход гиперкуба без чувства направления
требует Q(N logN) сообщений.

Раздел 6.4

Упражнение
6.12  Приведите пример вычисления алгоритма Тарри, в котором в результате
получается не DFS-дерево.

Упражнение
6.13  Составьте алгоритм, который вычисляет интервальные схемы
маркировки поиска в глубину (см. Подраздел 4.4.2) для произвольных связных
сетей.

Может
ли это быть сделано за O(N) единиц времени? Может ли это быть
сделано с использованием O(N) сообщений?

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

Раздел 6.5

Упражнение
6.15  Адаптируйте эхо-алгоритм (Алгоритм 6.5) для вычисления суммы по
входам всех процессов.

Упражнение
6.16  Предположим, что процессы в сетях, изображенных на Рис.6.21, имеют
уникальные идентификаторы, и каждый процесс имеет целочисленный вход.
Смоделируйте на обеих сетях вычисление фазового алгоритма, вычисляя множество S =
{(p, jp): p Î P} и сумму по входам.  

Упражнение
6.17  Какова цепочечная сложность фазового алгоритма для клик (Алгоритм
6.8) ?

 

 

7 
Алгоритмы выбора

В
этой главе будут обсуждаться проблемы выбора, также называемого нахождением
лидера. Задача выбора впервые была изложена ЛеЛанном [LeLann; LeL77],
который предложил и первое решение; см. Подраздел 7.2.1. Задача начинается в
конфигурации, где все процессы находятся в одинаковом состоянии, и приходит в
конфигурацию, где ровно один процесс находится в состоянии лидера
(leader), а все остальные – в состоянии проигравших (lost).

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

Существует
большое количество результатов о задаче выбора (как алгоритмы, так и более
общие теоремы). Результаты для включения в эту главу выбирались по следующим
критериям.

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

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

(3) Мы будем
уделять внимание порядку величины сложности сообщений, и не будем рассматривать
результаты, вносящие в сложность только постоянный множитель.

(4) Т.к.
результаты Кораха и др. (Раздел 7.4) подразумевают существование O(N logN)-алгоритмов
для нескольких классов сетей, алгоритм для клики с этой сложностью не будет
рассматриваться отдельно.

 

7.1  Введение

Задача
выбора требует, чтобы из конфигурации, где все процессы находятся в одинаковом
состоянии, система пришла в конфигурацию, где ровно один процесс находится в
особом состоянии лидер (leader), а все остальные процессы – в состоянии проигравших
(lost). Процесс, находящийся в состоянии лидер в конце вычисления,
называется лидером и говорят, что он выбран алгоритмом.

Определение
7.1  Алгоритм выбора – это алгоритм, удовлетворяющий следующим
требованиям.

(1) Каждый
процесс имеет один и тот же локальный алгоритм.

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

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

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

Во
всех алгоритмах этой главы процесс p имеет переменную statep с возможными
значениями leader (лидер) и lost (проигравший). Иногда мы будем
предполагать, что statep имеет значение sleep (спящий), когда
p еще не выполнил ни одного шага алгоритма, и значение cand (кандидат),
если p вступил в вычисление, но еще не знает, победил он или проиграл.
Некоторые алгоритмы используют дополнительные состояния, такие как active,
passive и др., которые будут указаны в самом алгоритме.

7.1.1  Предположения,
используемые в этой главе

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

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

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

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

(2) Каждый
процесс идентифицируется уникальным именем, своим идентификатором,
который известен процессу изначально. Для простоты предполагается, что
идентификатор процесса p – просто p. Идентификаторы извлекаются из совершенно
упорядоченного множества P, т.е.
для идентификаторов определено отношение £.
Количество бит, представляющих идентификатор, равно w.

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

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

(3) Некоторые
результаты этой главы относятся к алгоритмам сравнения. Алгоритмы сравнения
– это алгоритмы, которые используют сравнение как единственную операцию над
идентификаторами. Как мы увидим, все алгоритмы, представленные в этой главе,
являются алгоритмами сравнения. Всякий раз, когда дается оценка нижней границы,
мы явно отмечаем, касается ли она алгоритмов сравнения.

Было
показано (например, Бодлендером [Bodlaender, Bod91b] для случая кольцевых
сетей), что в асинхронных сетях произвольные алгоритмы не достигают лучшей
сложности, чем алгоритмы сравнения. Это не так в случае синхронных систем, как
будет показано в Главе 11; в этих системах произвольные алгоритмы могут
достигать лучшей сложности, чем алгоритмы сравнения.

(4) Каждое
сообщение может содержать O(w) бит. Каждое сообщение может содержать
не более постоянного числа идентификаторов процессов. Это предположение сделано
для того, чтобы позволить справедливое сравнение сложности сообщений различных
алгоритмов.

7.1.2  Выбор и волны

Уже
было замечено, что идентификаторы процессов могут использоваться для нарушения
симметрии между процессами. Можно разработать алгоритм выбора так, чтобы
выбирался процесс с наименьшим идентификатором. Согласно результатам в
Подразделе 6.1.5, наименьший идентификатор может быть вычислен за одну волну.
Это означает, что выбор можно провести, выполняя волну, в которой вычисляется
наименьший идентификатор, после чего процесс с этим идентификатором становится
лидером. Т.к. алгоритм выбора должен быть децентрализованным, этот принцип
может быть применен только к децентрализованным волновым алгоритмам (см.
Таблицу 6.19).

Выбор
с помощью древовидного алгоритма. Если топология сети – дерево или доступно
остовное дерево сети, выбор можно провести с помощью древовидного алгоритма
(Подраздел 6.2.2). В древовидном алгоритме требуется, чтобы хотя бы все листья
были инициаторами алгоритма. Чтобы получить развитие алгоритма в случае, когда
некоторые процессы также являются инициаторами, добавляется фаза wake-up.
Процессы, которые хотят начать выбор, рассылают сообщение <wakeup>
всем процессам. Логическая переменная ws используется, чтобы каждый
процесс послал сообщения <wakeup> не более одного раза, а переменная
wr используется для подсчета количества сообщений <wakeup>,
полученных процессом. Когда процесс получит сообщение <wakeup>
через каждый канал, он начинает выполнять Алгоритм 6.3, который расширен (как в
Теореме 6.12) таким образом, чтобы вычислять наименьший идентификатор и чтобы
каждый процесс принимал решение. Когда процесс принимает решение, он знает
идентификатор лидера; если этот идентификатор совпадает с идентификатором процесса,
он становится лидером, а если нет – проигравшим; см. Алгоритм
7.1.

var    wsp         :
boolean                                   init  false ;

          wrp         :
integer                                     init  0 ;

          recp[q]    :
boolean  для всех q Î Neighp
          init  false ;

          vp           :
P                                              init 
p ;

          statep      :
(sleep, leader, lost)                  init  sleep
;

begin 
if  p – инициатор  then

              begin 
wsp := true ;

                          forall 
q Î Neighp  do 
send <wakeup> to q

              end
;

          while 
wrp < # Neighp  do

              begin 
receive <wakeup> ; wrp := wrp + 1 ;

                         
if  not  wsp  then

                               begin 
wsp := true ;

                                           forall 
q Î Neighp  do
send <wakeup> to q

                               end

              end
;

          (*
Начало древовидного алгоритма *)

          while 
# {q : Ørecp[q]}
> 1  do

              begin 
receive <tok,r> from q ;  recp[q] := true ;

                          vp
:= min (vp,r)

              end
;

          send
<tok,vp>  to q0  with Ørecp[q0] ;

          receive
<tok,r>  from q0 ;

          vp
:= min (vp,r) ;   (* decide  с ответом vp *)

          if
vp = p  then  statep := leader  else
statep := lost ;

          forall 
q Î Neighp, q ¹ q0  do send <tok,vp> 
to q

end

Алгоритм 7.1 Алгоритм выборов для деревьев.

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

Доказательство.
Когда хотя бы один процесс инициирует выполнение алгоритма, все процессы посылают
сообщения <wakeup> всем своим соседям, и каждый процесс начинает
выполнение древовидного алгоритма после получения сообщения <wakeup>
от каждого соседа. Все процессы завершают древовидный алгоритм с одним и тем же
значением v, а именно, наименьшим идентификатором процесса. Единственный
процесс с этим идентификатором закончит выполнение в состоянии лидер, а
все остальные процессы – в состоянии проигравший.

Через
каждый канал пересылается по два сообщения <wakeup> и по два
сообщения <tok,r>, откуда сложность сообщений равна 4N-4. В
течение D единиц времени после того, как первый процесс начал алгоритм, каждый
процесс послал сообщения <wakeup>, следовательно, в течение D+1
единиц времени каждый процесс начал волну. Легко заметить, что первое решение
принимается не позднее, чем через D единиц времени после начала волны, а
последнее решение принимается не позднее D единиц времени после первого, откуда
полное время равно 3D+1. Более тщательный анализ показывает, что алгоритм
всегда завершается за 2D единиц времени, но доказательство этого оставлено
читателю; см. Упражнение 7.2.

Если
порядок сообщений в канале может быть изменен (т.е. канал – не FIFO), процесс
может получить сообщение <tok,r> от соседа прежде чем он получил
сообщение <wakeup> от этого соседа. В этом случае сообщение <tok,r>
может быть временно сохранено или обработано как сообщения <tok,r>,
прибывающие позднее.

Количество
сообщений может быть уменьшено с помощью двух модификаций. Во-первых, можно
устроить так, чтобы не-инициатор не посылал сообщение <wakeup>
процессу, от которого он получил первое сообщение <wakeup>.
Во-вторых, сообщение <wakeup>, посылаемое листом, может быть объединено
с сообщением <tok,r>, посылаемым этим листом. С этими изменениями
количество сообщений, требуемое алгоритмом, уменьшается до 3N-4+k, где k –
количество нелистовых стартеров [Tel91b, с.139].

Выбор
с помощью фазового алгоритма. Фазовый алгоритм можно использовать для
выбора, позволив ему вычислять наименьший идентификатор за одну волну, как в
Теореме 6.12.

Теорема
7.3  С помощью фазового алгоритма (Алгоритм 6.7) можно провести выбор в
произвольных сетях, используя O(D*|E|) сообщений и O(D) единиц
времени.

Алгоритм
Пелега [Peleg; Pel90] основан на фазовом алгоритме; он использует O(D*|E|)
сообщений и O(D) времени, но не требует знания D, т.к. включает в себя вычисление
диаметра.

Выбор
с помощью алгоритма Финна. Алгоритм Финна (Алгоритм 6.9) не требует, чтобы
диаметр сети был известен заранее. Длина O(N*|E|) сообщений, используемых в
алгоритме Финна, гораздо больше, чем допускаемая предположениями в этой главе.
Следовательно, каждое сообщение в алгоритме Финна должно считаться за O(N)
сообщений, откуда сложность сообщений составляет O(N2|E|).

 

7.2  Кольцевые сети

В
этом разделе рассматриваются некоторые алгоритмы выбора для однонаправленных
колец. Задача выбора в контексте кольцевых сетей была впервые изложена
ЛеЛанном [LeLann; LeL77], который также дал решение со сложностью сообщений O(N2).
Это решение было улучшено Чангом (Chang) и Робертсом (Roberts) [CR79], которые
привели алгоритм с наихудшей сложностью O(N2), но со средней
сложностью только O(N logN). Решения ЛеЛанна и Чанга-Робертса обсуждаются в
Подразделе 7.2.1. Вопрос о существовании алгоритма с наихудшей сложностью O(N
logN) оставался открытым до 1980 г., когда такой алгоритм был приведен
Hirschberg и Sinclair [HS80]. В отличие от более ранних решений, в решении
Hirschberg-Sinclair требуется, чтобы каналы были двунаправленными.
Предполагалось, что нижняя граница для однонаправленных колец равна W(N2), но Petersen [Pet82] и
Dolev, Klawe и Rodeh [DKR82] независимо друг от друга предложили решение,
составляющее O(N log N) для однонаправленного кольца. Это решение рассматривается
в Подразделе 7.2.2.

Алгоритмы
были дополнены соответствующими нижними границами примерно в то же время.
Нижняя граница для наихудшего случая для двунаправленных колец, равная » 0.34N logN  сообщений, была доказана Бодлендером
[Bodlaender; Bod88]. Pachl, Korach и Rotem [PKR84] доказали нижние границы в W(N logN) для средней сложности, как для
двунаправленных так и для однонаправленных колец. Их результаты по нижним
границам будут рассмотрены в Подразделе 7.2.3.

7.2.1  Алгоритмы ЛеЛанна и
Чанга-Робертса

В
алгоритме ЛеЛанна [LeL77] каждый инициатор вычисляет список идентификаторов
всех инициаторов, после чего выбирается инициатор с наименьшим идентификатором.
Каждый инициатор посылает маркер, содержащий его идентификатор, по кольцу, и
этот маркер передается всеми процессами. Предполагается, что каналы подчиняются
дисциплине FIFO, и что инициатор должен сгенерировать свой маркер до того, как
он получит маркер другого инициатора. (Когда процесс получает маркер, он после
этого не инициирует алгоритм.) Когда инициатор p получает свой собственный
маркер, маркеры всех инициаторов прошли через p, и p выбирается лишь в
том случае, если p – наименьший среди инициаторов; см. Алгоритм 7.2.

var    Listp       :
set of P        init  {p}
;

          statep
;

begin 
if  p – инициатор  then

              begin 
statep := cand ;  send <tok,p>  to Nextp
;  receive <tok,q> ;

                          while 
q ¹ p  do

                                    begin   Listp
:= Listp È {q} ;

                                                send
<tok,q>  to Nextp ;  receive <tok,q> ;

                                    end
;

                          if 
p = min (Listp)  then statep := leader

                                                    else
statep := lost

              end

            else 
repeat   receive <tok,q> ;  send <tok,q>  to Nextp
;

                                 if
statep = sleep  then  statep := lost

                     until
false

end

 

Алгоритм 7.2 Алгоритм выбора ЛеЛанна.

Теорема
7.4  Алгоритм ЛеЛанна (Алгоритм 7.2) решает задачу выбора для колец, используя
O(N2) сообщений и O(N) единиц времени.

Доказательство.
Так как порядок маркеров в кольце сохраняется (из предположения о каналах
FIFO), и инициатор q отправляет <tok,q> до того как получит
<tok,p>, то инициатор p получает <tok,q> прежде, чем
вернется <tok,p>. Отсюда следует, что каждый инициатор p
заканчивается со списком Listp, совпадающим с множеством всех
инициаторов, и единственным выбираемым процессом становится инициатор с
наименьшим идентификатором. Всего получается не больше N маркеров и каждый
делает N шагов, что приводит к сложности сообщений в O(N2). Не
позднее чем через N-1 единицу времени после того, как первый инициатор отправил
свой маркер, это сделали все инициаторы. Каждый инициатор получает свой маркер
обратно не позднее, чем через N единиц времени с момента генерации этого
маркера. Отсюда следует, что алгоритм завершается в течение 2N-1 единиц
времени.

Все
не-инициаторы приходят в состояние проигравший, но навсегда остаются в
ожидании сообщений <tok,r>. Ожидание может быть прервано, если
лидер посылает по кольцу специальный маркер, чтобы объявить об окончании
выбора.

Алгоритм
Чанга-Робертса [CR79] улучшает алгоритм ЛеЛанна, устраняя из кольца маркеры тех
процессов, для которых очевидно, что они проиграют выборы. Т.е. инициатор p
удаляет из кольца маркер <tok,q>, если q > p. Инициатор p
становится проигравшим, когда получает маркер с идентификатором
q < p, или лидером, когда он получает маркер с идентификатором p; см.
Алгоритм 7.3.

var statep
;

begin 
if  p – инициатор  then

              begin
 statep := cand ;  send <tok,p>  to Nextp
;

                          repeat receive
<tok,q> ;

                                      if 
q = p  then  statep := leader

                                                    else
if  q < p  then

                                                                begin 
if statep = cand  then  statep := lost
;

                                                                            send
<tok,q>  to Nextp

                                    end

                          until 
statep = leader

              end

            else
repeat receive <tok,q> ;  send <tok,q>  to Nextp
;

                               if
statep = sleep  then statep := lost

                   until
false

end

(* Только
лидер завершает выполнение программы. Он передает сообщение всем процессам,
чтобы сообщить им идентификатор лидера и завершить их *)

 

Алгоритм 7.3 Алгоритм выбора Чанга-Робертса.

 

Теорема
7.5  Алгоритм Чанга-Робертса (Алгоритм 7.3) решает задачу выбора для
колец, используя Q(N2) сообщений
в наихудшем случае и O(N) единиц времени.

Доказательство.
Пусть p0 – инициатор с наименьшим идентификатором. Все процессы
являются либо не-инициаторами, либо инициаторами с идентификаторами большими p0,
поэтому все процессы передают дальше маркер <tok,p0>,
отправленный p0. Следовательно, p0 получает свой маркер
обратно и становится выбранным.

Не-инициаторы
не могут быть выбраны, т.к. все они приходят в состояние проигравший
самое позднее, когда через них передается маркер p0. Инициатор p  с
p > p0 не может быть выбран; p0 не передаст
дальше маркер <tok,p>, поэтому p никогда не получит свой
собственный маркер. Такой инициатор p приходит в состояние проигравший
самое позднее, когда через него передается маркер <tok,p0>.
Таким образом доказано, что алгоритм решает задачу выбора.