CC BY
25
Проблема отката в ориентированной распределенной системе
И.Б. Бурдонов <[email protected]>1 А.С. Косачев <кв[email protected]> Институт системного программирования РАН, 109004, Россия, г. Москва, ул. А. Солженицына, д. 25.
Аннотация. Для распределенной системы, в основе которой лежит ориентированный граф без кратных ребер и петель, рассматривается проблема отката (backtracing problem): как передать сообщение от конца дуги в ее начало. Ставится задача создания на графе структуры, позволяющей передавать сообщение из конца любой дуги в ее начало по кратчайшему пути. Такая структура в каждой вершине a задаётся отображением номера вершины b в номер исходящей дуги, через которую проходит кратчайших путь от a к b. В частности, такое отображение позволяет симулировать в ориентированных распределенных системах алгоритмы решения задач на графе, разработанные для неориентированных распределенных систем. Это увеличивает время работы таких алгоритмов (в тактах, где время пересылки сообщения по дуге не превосходит 1 такт) не более чем в к раз, где к диаметр графа, к < n, и n - число вершин графа. В разделе 2 описывается используемая асинхронная модель распределенной системы. Раздел 3 содержит основные определения и обозначения, а раздел 4 -постановку задачи. В разделе 5 описываются два вспомогательных алгоритма коррекции поддеревьев, применение которых позволяет строить остовные деревья кратчайших путей: прямого дерева, ориентированного от корня графа, и обратного дерева, ориентированного к корню графа. Раздел 6 содержит описание различных способов передачи сообщений по графу. В разделе 7 предлагаются два алгоритма построения в памяти автомата корня графа описаний прямого и обратного остовных деревьев кратчайших путей, а в разделе 8 - основанные на них алгоритмы построения требуемого отображения: «быстрый» алгоритм с оценками T=O(n) и N=O(n) и «экономный» алгоритм с оценками T=O(n2) и N=O(1), где T - время (в тактах) работы алгоритма, N - число сообщений, одновременно передаваемых по дуге. В разделе 9 доказано, что эти оценки времени не улучшаемые. В разделе 10 «быстрый» алгоритм модифицируется для синхронной модели с N=1. Заключение подводит итоги и намечает направления дальнейших исследований.
Ключевые слова: ориентированный граф; корневой граф; нумерованный граф; распределенные алгоритмы; задачи на графах; проблема отката; кратчайшие пути.
DOI: 10.15514/ISPRAS-2018-30(2)-9
1 Работа частично поддержана проектом РФФИ № 17-07-00682 А.
Для цитирования: Бурдонов И.Б., Косачев А.С. Проблема отката в ориентированной распределенной системе. Труды ИСП РАН, том 30, вып. 2, 2018 г., стр. 167-194. DOI: 10.15514/ISPRAS-2018-30(2)-9
1. Введение
Распределенная система - это граф, в вершинах которого располагаются вычислительные единицы (автоматы), которые могут обмениваться между собой сообщениями, посылаемыми по ребрам графа. Если граф ориентированный, то ориентированное ребро называется дугой и соответствует симплексному каналу передачи сообщений: сообщение может передаваться по дуге только в одном направлении: от начала дуги к концу дуги. Это создает проблему отката (backtracking problem): как передать сообщение от конца дуги в ее начало?
Первоначально эта проблема изучалась в контексте обхода ориентированного графа роботом (конечным автоматом), двигающимся по дугам графа [1][2][3]. Модель с одним двигающимся роботом эквивалентна «инвертированной» модели с одним сообщением, передаваемым по графу, и идентичными роботами, находящимися в вершинах графа: робот в вершине, принимая сообщение по некоторой входящей дуге, посылает одно сообщение по одной исходящей дуге или завершает работу алгоритма. Длина обхода ориентированного графа без кратных ребер равна O(n2), где n - число вершин. Однако из-за проблемы отката оценка алгоритмического обхода увеличивается, в зависимости от алгоритма, до O(n2logn) [1], O(n2loglogn) [2], а наилучший известный результат равен O(n2log*n) [3], где log* -итерированный логарифм (количество итеративных логарифмирований аргумента, необходимых для того, чтобы результат стал меньше или равен 1). В данной работе мы исследовали проблему отката для распределенной системы, в которой может быть несколько сообщений, одновременно передаваемых по дугам графа. Граф предполагается нумерованным: вершинам присвоены номера от 1 до n. Граф корневой, т.е. имеется выделенная вершина, называемая корнем графа, с которой начинается и в которой заканчивается выполнение алгоритма. Граф упорядоченный: дуги, выходящие из вершины перенумерованы от 1 до полустепени исхода этой вершины. Заметим, что упорядоченность графа необходима для того, чтобы автомат в вершине мог указывать исходящую дугу, по которой он хочет передать сообщение. Сообщение перемещается по дуге за время не более 1 такта. Мы поставили задачу создания на графе структуры, позволяющей передавать сообщение из конца любой дуги в ее начало по кратчайшему пути, т.е. за минимальное время в наихудшем случае, когда по каждой дуге сообщение пересылается 1 такт. В памяти автомата каждой вершины a эта структура задается отображением номера вершины b в номер исходящей дуги, через которую проходит кратчайший путь от a к b. В частности, такое отображение позволяет симулировать в ориентированных распределенных системах
алгоритмы решения задач на графе, разработанные для неориентированных распределенных систем (например, [4][5]). Вместо прохода по одной дуге в обратном направлении проходится ориентированный путь из конца дуги в её начало, что увеличивает время работы таких алгоритмов не более чем в k раз, где k < п диаметр графа (максимальное расстояние между вершинами). В разд. 2 описывается используемая асинхронная модель распределенной системы. Разд. 3 содержит основные используемые определения и обозначения, а разд. 4 - постановку задачи. В разд. 5 описываются два вспомогательных алгоритма коррекции поддеревьев, применение которых в последующих алгоритмах позволяет строить остовные деревья кратчайших путей: прямого дерева, ориентированного от корня графа, и обратного дерева, ориентированного к корню графа. Разд. 6 содержит описание пяти различных способов передачи сообщений по графу, которые используются в алгоритмах, описываемых ниже.
В разд. 7 предлагаются два алгоритма построения в памяти автомата корня графа описаний прямого и обратного остовных деревьев кратчайших путей. Эти алгоритмы отличаются соотношением времени T работы и числа N сообщений, одновременно передаваемых по дуге: в «быстром» алгоритме T=0(n) и N=0^), а в «экономном» алгоритме T=0(n2) и N=0(1). Разд. 8 содержит описание двух основных алгоритмов построения требуемого отображения, т.е. отображения в каждой вершине a номера другой вершины Ь в номер первой дуги на кратчайшем пути из a в Ь. «Быстрый» алгоритм имеет оценки T=0(n) и N=0^), «экономный» алгоритм имеет оценки T=0(n2) и N=0(1). В разд. 9 доказано, что эти оценки не улучшаемы. Разд. 10 посвящён синхронной модели, в которой любое сообщение перемещается по любой дуге ровно за 1 такт. Заключение подводит итоги и намечает направления дальнейших исследований.
2. Модель
Граф распределенной системы предполагается ориентированным, сильно связным, нумерованным, корневым и упорядоченным без кратных дуг и петель. Емкостью дуги называется число сообщений, которые могут одновременно перемещаться по дуге. В рассматриваемой модели предполагается неограниченная емкость дуги. Это означает, что автомат в вершине не получает каких-либо «извещений» о том, что исходящая дуга уже полностью «заполнена» или, наоборот, «освободилась». Но для предлагаемых алгоритмов мы будем давать оценку числа сообщений на дуге. Будем считать, что в одном срабатывании автомат принимает ровно одно сообщение ровно по одной входящей дуге и посылает по каждой исходящей дуге не более одного сообщения. Для удобства описания алгоритма мы будем иногда говорить, что в одном срабатывании автомат посылает по одной исходящей дуге несколько (но конечное число) сообщений m1,m2,...me, имея в виду, что они «склеиваются» в одно сообщение m = m1•m2•...me. Число в таких
169
сообщений во всех предлагаемых ниже алгоритмах не превосходит 3. Принимая такое «склеенное» сообщение m, автомат запоминает его в своей памяти и обрабатывает его компоненты m1,m2,...me последовательно, как если бы он принял их в последовательных e срабатываниях. Мы будем пренебрегать временем срабатывания автомата в вершине, т.е. будем оценивать сложность алгоритмов как время перемещения сообщений по дугам.
Для краткости там, где это не приведёт к недоразумениям, мы будем вместо «автомат в вершине» или «память автомата в вершине» говорить просто «вершина» или «память вершины». Память вершины будет рассматриваться как набор переменных, а сообщение - как набор параметров. Мы будем давать следующие оценки алгоритмов: T - время работы алгоритма, A - размер памяти вершины как сумма размеров (в битах) переменных, M -размер сообщения как сумма размеров (в битах) параметров сообщения, N -число сообщений, одновременно передаваемых по одной дуге. Время перемещения сообщения по одной дуге считается ограниченным сверху одним тактом.
3. Определения и обозначения
Определения:
• Маршрут - последовательность дуг графа, в которой конец не последней дуги совпадает с началом следующей дуги.
• Путь - маршрут, в котором никакие две дуги не имеют общего конца, и конец последней дуги не совпадает с началом первой дуги.
• Расстояние от вершины a до вершины b - длина кратчайшего пути от вершины a до вершины b.
• Прямое дерево - дерево с выделенным корнем дерева, в котором все дуги ориентированы от корня дерева.
• Обратное дерево - дерево с выделенным корнем дерева, в котором все дуги ориентированы к корню дерева.
• Прямое дерево кратчайших путей - такой подграф, являющийся прямым деревом, что расстояние от корня дерева до каждой вершины дерева по дереву и по графу одинаковы.
• Обратное дерево кратчайших путей - такой подграф, являющийся обратным деревом, что расстояние от каждой вершины дерева до корня дерева по дереву и по графу одинаковы.
• Остов графа, остовное дерево - подграф, являющийся деревом и содержащий все вершины графа.
Далее граф G, лежащий в основе распределенной системы, предполагается ориентированным сильно-связным простым нумерованным упорядоченным корневым графом. В переменных вершин и параметрах сообщений описание
вершины - это ее номер, а описание дуги - это тройка чисел (а,/,Ь), где а -номер начала (начальной вершины) дуги, / - номер дуги в вершине а, Ь -номер конца (конечной вершины) дуги. Связный подграф будем задавать множеством таких троек чисел, представляющих все его дуги. В тривиальном случае, когда связный подграф не имеет дуг, он состоит из одной вершины, и будет задаваться синглетоном, содержащим номер этой вершины. Маршрут будет задаваться последовательностью дуг (троек чисел); маршрут нулевой длины - пустая последовательность <>. Обозначения:
• г - корень графа.
• d"(a) - полустепень исхода вершины а (число исходящих из нее дуг).
• йТ+(а) - полустепень захода вершины а (число входящих в нее дуг).
• а—- дуга, задаваемая тройкой (а,/',Ь).
• а—- означает, что для некоторого Ь существует дуга а—1^-Ь.
• а^Ь - означает, что для некоторого / существует дуга а—г'^Ь.
• У(Н - множество вершин, инцидентных дугам множества дуг Н.
4. Постановка задачи
Для того, чтобы в графе О с п вершинами из каждой вершины можно было попасть в каждую вершину по кратчайшему пути, нужно отображение /О) : [1.п]х[1..п]^[0.п-1], которое каждой паре вершины с номерами а и Ь ставит в соответствие номер дуги, с которой начинается кратчайший путь из а в Ь, если афЬ, или 0 в противном случае. В каждой вершине ае[1.п] достаточно хранить часть этого отображения как отображение /а(О) : [1.п]^[1..йТ(а)] такое, что УЬе[1..п] /а(О)(Ь) = /(О)(а,Ь). Если граф О подразумевается, мы будем вместо /О) и/а(О) писать просто/и/а. Размер памяти вершины а, необходимый для хранения такого отображения, равен O(nlogd'(а)) = O(nlogn), что на порядок меньше памяти для хранения всего неупорядоченного графа 0(п2) (матрица смежности [1..п]х[1..п]^{0Д}) и, тем более, упорядоченного графа 0(n2logn) (матрица смежности с указанием номеров дуг [1..п]х[1..п]^[0..п]) [6]. Поскольку отображение имеет размер 0(nlogn), то в любом алгоритме размер памяти вершины А = Q.(nlogn). Мы ставим задачу: построить отображение / и разместить в каждой вершине а отображение /,. В этой статье мы предлагаем четыре результата, графически изображенные на рис. 1 и описываемые в следующих разделах.
S.2:1= (Kr?) A = (Knhgn) M= 0{nloxn) -V= Oil)
9:
A unlimited M unlimited Л=0(1)
Рис. 1. Алгоритмы построения отображения и их оценки Fig. 1. Algorithms for constructing a map and their estimates
5. Коррекция деревьев
5.1. Коррекция прямого дерева
Пусть все вершины графа H достижимы из вершины х, и имеется прямое дерево DcH с корнем в х. Определим коррекцию дерева, когда становится известным о существовании дуги a—i^-beHD с началом в D, т.е. aeV(D). Если bg V(D), то дуга a—i^b добавляется в D: D := D \ {a} и {а—i^-b}. Если beV(D), то в D есть единственная дуга a~—i ^b, заканчивающаяся в b. Если по дереву D расстояние от х до a, увеличенное на 1, меньше, чем расстояние от х до b, то дуга a—i^b заменяет в D дугу as—i'^-b: D := D и {a—i^b} \ {a'—i ^b}. Следующее утверждение очевидно, и мы приводим его без доказательства: если такая коррекция применяется последовательно для каждой дуги графа, то в итоге будет получено прямое остовное (для H) дерево кратчайших путей с корнем в х.
5.2. Коррекция обратного дерева
Пусть из всех вершин графа H достижима вершина х, и имеется обратное дерево DcH с корнем в х. Определим коррекцию дерева, когда становится известным о существовании дуги a—i^beH\D с концом в D, т.е. beV(D). Если ag V(D), то дуга a—i^b добавляется в D: D := D \ {b} и {a—i^-b}. Если aeV(D), то в D есть единственная дуга a—i'^-b', начинающаяся в a. Если по дереву D расстояние от b до х, увеличенное на 1, меньше, чем расстояние от a до х, то дуга a—i^b заменяет в D дугу a—i'^-b': D := D и {a—i^b} \ {a—i'^-b'}. Следующее утверждение очевидно, и мы приводим его без доказательства: если такая коррекция применяется 172
последовательно для каждой дуги графа, то в итоге будет получено обратное остовное (для H) дерево кратчайших путей с корнем в x.
6. Способы передачи сообщений
В описываемых ниже алгоритмах используется пять типов передачи сообщений. Мы определим эти способы здесь, указывая параметры сообщения и переменные в вершинах, которые используются в этих способах передачи. В дальнейшем будем просто ссылаться на способ передачи того или иного сообщения, указывая также дополнительные параметры.
6.1. Рассылка из корня
Параметры сообщения: отсутствуют. Это сообщение должно пройти по каждой дуге графа ровно один раз. В каждой вершине x имеется булевская переменная s(x); вначале s(x) = false. Сообщение создается корнем r и посылается им по каждой исходящей из корня дуге графа. Когда вершина х-ф-r получает сообщение, она анализирует переменную s(x). Если s(x) = false, сообщение пересылается дальше по каждой исходящей из х дуге графа и s(x) := true. Если s(x) = true, ничего не делается. Заметим, что условие s(x) = false является единственным условием, которое должно быть выполнено в каждой вершине перед началом работы любого алгоритма; можно считать, что это часть начального состояния вершины.
6.2. Множественная рассылка
Параметры сообщения: номер вершины x, создавшей сообщение. Это сообщение распространяется по графу аналогично рассылке из корня, но только создателем сообщения может быть другая вершина, и таких вершин может быть несколько. В каждой вершине x имеется множество S(x) вершин-создателей, от которых получено сообщение; вначале S(x) = 0. Когда вершина x создаёт сообщение, S(x) := S(x) u {x}. Когда вершина x^y получает сообщение, созданное вершиной у, она анализирует множество S(x). Если ygS(x), сообщение пересылается дальше по каждой исходящей из x дуге графа и S(x) := S(x) u {y}. Множество S(x) можно задавать битовой шкалой длины n.
6.3. Пересылка по прямому дереву
Параметры сообщения: описание прямого дерева F(x) с корнем в вершине x, номер вершины ye V(F(x)). Сообщение передается по прямому дереву F(x) от x до у. Когда вершина z^y получает сообщение, она пересылает его дальше по исходящей из z дуге дерева F(x), ведущей вy, т.е. первой дуге на пути от x до y в дереве F(x).
Burdonov I.B., Kossatchev A.S. Directed distributed system: Backtracking problem. Trudy ISP RAN/Proc. ISP RAS, vol. 30, issue 2, 2018, pp. 167-194_
6.4. Пересылка по обратному дереву
Параметры сообщения: описание обратного дерева R(x) с корнем в вершине x. Сообщение передается по обратному дереву R(x) до вершины x. Когда вершина z^x получает сообщение, она пересылает его дальше по исходящей из z дуге дерева R(x).
6.5. Сбор по обратному дереву
Параметры сообщения: описание обратного дерева R(x) с корнем в вершине x, булевский признак q. В каждой вершине z имеются счетчик c(z) и переменная m(z), в которой может храниться сообщение; вначале c(z) = 0. Из каждой вершины ze V(R(x))\{x} будет послано одно сообщение по исходящей из z дуге дерева R(x), но только после того, как вершина z получит сообщение по каждой входящей в z дуге дерева R(x) и сама создаст сообщение. Для подсчета числа сообщений используется счетчик c(z), который увеличивается на 1, когда вершина z получает сообщение или создает его сама. Полученное или созданное вершиной z сообщение запоминается в переменной m(z), если там уже не запомнено сообщение с q = true. Когда c(z) на 1 больше числа дуг дерева R(x), входящих в z, запомненное в m(z) сообщение посылается по исходящей из z дуге дерева R(x). В результате вершина x получит ровно одно сообщение по каждой входящей в x дуге дерева R(x). Среди полученных вершиной x сообщений (включая сообщение, созданное вершиной x) будет сообщение с q = true тогда и только тогда, когда хотя бы одна вершина из V(R(x)) создала сообщение с q = true. Такой способ передачи сообщений будем называть «сбором по обратному остову».
7. Алгоритмы построения в корне описаний прямого и обратного остовных деревьев кратчайших путей
В этом разделе предложены два алгоритма построения в корне описаний прямого F и обратного R остовных деревьев кратчайших путей, а в каждой вершине x - описания множества In(x) входящих дуг. Оценки: в «быстром» алгоритме T = O(n), N = O(n), в «экономном» алгоритме T = O(n2), N = O(1), остальные оценки совпадают: A = O(nlogn) и M = O(nlogn).
7.1. «Быстрый» алгоритм
Идея алгоритма заключается в следующем. Сначала рассылкой из корня по графу распространяется сообщение «Старт». Оно пройдет по каждой дуге ровно один раз, что требует времени не более n тактов. Это сообщение накапливает в себе описание пройденного им маршрута Fp. Когда сообщение приходит в вершину x, Fp запоминается в ней. Множество маршрутов, запомненных в x, образует подграф H(x), состоящий из прямого дерева с корнем в r и множества In(x) дуг, ведущих из его листьев в x. Поэтому число дуг в H(x) ограничено по порядку n, что ограничивает размер описания H(x)
порядком nlogn. Получив «Старт» с параметром Fp, вершина создает сообщение «Возврат», которое распространяется по графу множественной рассылкой, что гарантирует доставку сообщения в корень. На одной дуге может оказаться O(n) сообщений «Возврат». «Возврат» содержит как параметр Fp (из сообщения «Старт»), и тоже накапливает в себе описание пройденного им маршрута Rp. Получая «Старт» с Fp (это цикл) или «Возврат» с Fp и Rp (вместе образуют цикл), корень формирует описание текущих прямого F и обратного R деревьев на множестве вершин V = V(F) = V(R); размер описания тоже ограничен по порядку nlogn. Корень в цикле организует опрос вершин в старт-стопном режиме.
Сообщение «Опрос» передается рассылкой по дереву F, а корень запоминает число w := |V вершин, которые получат «Опрос». Получив «Опрос», вершина х создает сообщение «Ответ», в котором указывает H(x) и полустепень исхода d(x). «Ответ» передается пересылкой по дереву R. Поэтому на одной дуге может оказаться O(n) сообщений «Ответ». Корень, получая H(x), образованный маршрутами от корня до xeV, корректирует (см. п. 5.1 и п. 5.2) описания деревьев F и R (соответственно меняется V) так, чтобы это были деревья кратчайших путей. Корень запоминает D+(x) := |In(x)| и D'(x) := d(x). Когда корень получит «Ответ» от всех w вершин, проверяется условие завершения алгоритма: 1) полустепень исхода d-(x) запомнена в D-(x) для каждой xe V, т.е. D"(x) > 0, 2) суммарное число известных входящих дуг равно суммарному числу исходящх дуг Exe V D+(x) = ExeV D"(x).
7.1.1. Начало работы
Корень r инициализирует S(r) := {r}, F := {r}, R := {r}, D"(r) := d(r), D+(r) := 0, In(r) := 0. Если нет дуг, исходящих из r, алгоритм заканчивается. В противном случае создается сообщение «Старт» и посылается по каждой исходящей из r дуге j с параметрами (<>, r, j).
7.1.2. Сообщение «Старт», рассылка из корня
Параметры сообщения при передаче по дуге a—i^-x: a, i, Fp - маршрут, пройденный сообщением от r до a. Обозначим Fp" := Fp-<a—i^x>. Вершина x^r, получив «Старт» первый раз (s(x) = false), инициализирует S(x) := {x}, H(x) := Fp\ In(x) := {a—i^x}, пересылает «Старт» по каждой исходящей из x дуге j с параметрами (Fp , x, j), и создает сообщение «Возврат», которое тоже посылает по каждой исходящей из x дуге j с параметрами (Fp , <>, x, j). При повторном (s(x) = true) получении «Старта» H(x) := H(x) u Fp\ In(x) := In(x) u {a—i^x}, «Старт» дальше не посылается и «Возврат» не создается. Корень r, получая «Старт», увеличивает D(r) := D(r)+1, In(r) := In(r) u {a—i^r}, для каждого ye V(Im(Fp))\V добавляет D+(y) := 0 и D'(y) := 0. Затем корректируется F (см. п.5.1) перебором дуг Fpy от начала к концу, и корректируется R (см. п.5.2) перебором дуг Fpy от конца к началу.
После этого корень создает сообщение «Опрос» с параметрами (F, R) и посылает его по исходящим из корня дугам F, запоминая w := |V|.
7.1.3. Сообщение «Возврат», множественная рассылка
Параметры сообщения при передаче по дуге a—i^z: a, i, Fp, Rp, где Fp -это маршрут, пройденный сообщением «Старт» от r до некоторой вершины x, которая создает сообщение «Возврат», Rp - это маршрут, пройденный сообщением «Возврат» от вершины x до вершины a. Обозначим Rp" := Rp-<a—i^z>. Когда «Возврат» приходит в вершину z, проверяется, является ли это сообщение первым или повторным от вершины x. Если xg S(z), это первое сообщение. Тогда, если z Ф r, «Возврат» пересылается дальше по каждой исходящей из z дуге j с параметрами (Fp, Rp\z, j). Если z = r, корень для каждого ye V(/m(Fp)u/m(Rp))\V добавляет D+(y) := 0 и D'(y) :=0, корректирует F (см. п.5.1), перебирая дуги Fp-Rpy от начала к концу, и корректирует R (см. п.5.2), перебирая дуги Fp-Rpy от конца к началу. Повторный (xeS(z)) «Возврат» игнорируется.
7.1.4. Сообщение «Опрос», рассылка по дереву F
Параметры сообщения: F, R, где F прямое, а R обратное остовные деревья кратчайших путей с корнем в r. Когда сообщение «Опрос» приходит в вершину x, оно пересылается дальше по всем исходящим из x дугам дерева F. Кроме того, вершина x создает сообщение «Ответ», которое посылается по исходящей из x дуге дерева R.
7.1.5. Сообщение «Ответ», пересылка по дереву R
Параметры сообщения при создании в вершине x: R, H(x), d"(x). Когда вершина z Ф r получает «Ответ», она пересылает его по исходящей из z дуге дерева R. Когда корень получает «Ответ», он запоминает D (x) := |In(x)|, D-(x) := d"(x), для каждого yeV(H(x))\V добавляет D+(y) := 0 и D'(y) :=0. Далее корректируется F (см. п.5.1) перебором дуг из H(x) от корня к x, и корректируется R (см. п.5.2) перебором дуг из H(x) от x к корню. Корень дожидается w «Ответов» и проверяет условие конца работы.
7.1.6. Конец алгоритма
Конец работы определяет корень при выполнении условия: 1) Vxe VD'(x) > 0, 2) ExeVD(x) = ExeVD"(x). Если условие не выполнено, корень снова создает и рассылает сообщение «Опрос», запоминая w = |V|.
Покажем, что алгоритм заканчивается через конечное время (в тактах) и определим его оценки. За время t1 < n сообщение «Старт» пройдет по каждой дуге, в том числе по каждой входящей дуге корня. После этого за время t2 < n-1 сообщение «Возврат» от каждой вершины дойдет до корня. Поэтому через время не более t1 + t2 будет V = V(G). Сообщения «Опрос» проходят дерево F за время не более n-1, а сообщения «Ответ» проходят дерево R за время не более n-1. Поэтому цикл «Опрос»-«Ответ» длится не более 2(n-1) 176
тактов. Поэтому через время не более ^ + /2 + 2(п-1) начнется очередной цикл, в котором каждая вершина х Ф г создает «Ответ» с \1п(х)\ = й+х). После получения корнем всех «Ответов» на этот «Опрос» будет выполнено условие конца работы. Следовательно, время работы алгоритма Т < ^+/2+2(п-1)+2(п-1) = 0(п). Из описания алгоритма следует, что N = 0(п), А = 0(nlogn), М = 0(nlogn). Покажем, что в конце работы алгоритма Е и К остовные деревья кратчайших путей. В этот момент времени V = У(О), т.е. деревья Е и К остовные. Кроме того, для каждой вершины xeV в корне хранится Б'(х) = аГ(х). Поэтому условие окончания алгоритма может быть выполнено только в том случае, когда Б+(х) = а (х) для каждой вершины хе V. Следовательно, для каждой дуги у—корень получил такой «Ответ» от х, что у—г^хеН(х). В этот момент времени xеV, а в Н(х) существует путь, начинающийся в корне, последняя дуга которого - это дуга у—1^х. Это значит, что каждая дуга графа участвует в коррекции деревьев Е и К. Следовательно, по утверждениям в 5.1 и 5.2 Е и К деревья кратчайших путей.
7.2. «Экономный» алгоритм
Идея этого алгоритма заключается в такой модификации «быстрого» алгоритма из п.7.1, чтобы уменьшить оценку N с О(п) до 0(1) за счет увеличения времени работы не более чем в п раз. Причиной оценки N = 0(п) являются способы передачи сообщения «Возврат» - множественная рассылка, и сообщения «Ответ» - пересылка по дереву К. Сообщение «Возврат» мы удалим. Теперь у нас не будет времени /2 и гарантии того, что корень узнает о всех вершинах графа через время ^ + /2 = 0(п). Корень будет узнавать о вершинах только при получении «Старт» и «Ответ». «Ответ» на данный «Опрос» будет передаваться не пересылкой по дереву К, а сбором по дереву К. При создании «Ответа» вершиной х признак q := (0+(х) < \ \п(х)\) показывает, что множество Н(х) (и, тем самым, и множество \п(х)) изменилось по сравнению с тем, которое уже попало в корень.
В результате при каждом опросе в корень придет только один «Ответ» по каждой входящей в корень дуге дерева К, причем признак q в нем будет истинен тогда и только тогда, когда в соответствующем поддереве дерева Е хотя бы в одной вершине х изменилось Н(х). Заметим, что при ложном признаке q в «Ответе» от х не нужны параметры Н(х) и сГ(х), но эта оптимизация не влияет на оценки алгоритма. За все время работы алгоритма от каждой вершины х может придти только один «Ответ» с истинным признаком q и \п(х)\ = а(х). Поэтому после времени ^ будет не более п циклов «Опрос»-«Ответ», после чего условие конца работы будет выполнено.
7.2.1. Начало работы
Корень г инициализирует Е := {г}, К := {г}, Б'(г) := йТ(г), Б+(г) := 0, \п(г) := 0. Затем корень посылает «Старт» по каждой исходящей из г дуге ] с параметрами (<>, г, ]), если такие дуги есть. Если дуг нет, то конец алгоритма.
177
Burdonov I.B., Kossatchev A.S. Directed distributed system: Backtracking problem. Trudy ISP RAN/Proc. ISP RAS, vol. 30, issue 2, 2018, pp. 167-194_
7.2.2. Сообщение «Старт», рассылка из корня
Параметры сообщения при передаче по дуге a—i—x: a, i, Fp - маршрут, пройденный сообщением от r до a. Обозначим Fp" := Fp-<a—i—x>. Вершина x^r, получив «Старт» первый раз (s(x) = false), инициализирует H(x) := Fp\ In(x) := {a—i—Kx}, пересылает «Старт» по каждой исходящей из x дуге j с параметрами (Fp\ x, j). При повторном (s(x) = true) получении «Старта» H(x) := H(x) u Fp\ In(x) := In(x) u {a—i—x}, «Старт» дальше не посылается. Корень, получая «Старт», увеличивает D+(r) := D (r)+1, In(r) := In(r) u {a—i—r}, для каждого ye V(Im(Fp))\V добавляет D+(y) := 0 и D'(y) :=0, корректирует F (см. п.5.1), перебирая дуги Fp" от начала к концу, и корректирует R (см. п.5.2), перебирая дуги Fp" от конца к началу. Корень сбрасывает счетчик c(r) := 1, создает сообщение «Опрос» с параметрами (F, R, D+) и посылает его по исходящим из корня дугам F.
7.2.3. Сообщение «Опрос», рассылка по дереву F
Параметры сообщения: F, R, D+. Когда сообщение «Опрос» приходит в вершину x, оно пересылается дальше по всем исходящим из x дугам дерева F. Также создается сообщение «Ответ» с q = (D (x) = |In(x)|). Если x - листовая вершина R, «Ответ» посылается по исходящей из x дуге дерева R. Иначе «Ответ» запоминается в m(x) и c(x) := 1.
7.2.4. Сообщение «Ответ», сбор по дереву R
Параметры сообщения при создании в вершине x: признак q, R, H(x), d(x). Когда вершина z Ф r получает «Ответ», c(z) := c(z)+1. Если q = true, вершина z запоминает «Ответ» в m(z) вместо ранее запомненного «Ответа». Далее, если счетчик c(z) на 1 больше числа дуг дерева R, входящих в вершину z, запомненный в m(z) «Ответ» посылается по исходящей из z дуге дерева R. Когда корень получает сообщение, c(r) := c(r)+1. Если признак q = true, корень запоминает D+(x) := |In(x)|, D-(x) := eT(x), для каждого ye V(H(x))\V добавляет D+(y) := 0 и D'(y) := 0. Далее корректируется F (см. п.5.1) перебором дуг из H(x) от корня к x, и корректируется R (см. п.5.2) перебором дуг из H(x) от x к корню. Если c(r) меньше или равен числа дуг дерева R, входящих в корень, корень продолжает ждать «Ответы», иначе проверяет условие конца работы.
7.2.5. Конец алгоритма
Конец работы определяет корень при выполнении условия: 1) Vxe VD'(x) > 0, 2) ExeVD(x) = ExeVD"(x). Если условие не выполнено, корень снова создает и рассылает сообщение «Опрос», сбрасывая счетчик c(r) := 1. Покажем, что алгоритм заканчивается через конечное время и определим его оценки. За время t1 < n сообщение «Старт» пройдет по каждой дуге, в том числе по каждой входящей дуге корня. От каждой вершины x сообщение «Ответ» с q = true и |In(x)| = et(x) может придти в корень не более одного раза. Поэтому таких сообщений «Ответ» может придти в корень не более n. Сообщения «Опрос» проходят дерево F за время не более n-1, а сообщения 178
«Ответ» проходят дерево R за время не более n-1. Поэтому цикл «Опрос»-«Ответ» длится не более 2(n-1) тактов. Первый цикл «Опрос»-«Ответ», начинающийся после времени t1, начнется не позже времени t1+2(n-1), а всего циклов, начинающихся после времени t1, будет не более n. Следовательно, время работы алгоритма T < t1+2(n-1)+n(2(n-1)) = O(n2). Из описания алгоритма следует, что на одной дуге может находиться либо не более одного сообщения «Старт», либо не более одного сообщения «Опрос» и (если это дуга из FnR) не более одного сообщения «Ответ». Поэтому N < 2 = O(1). Также из описания алгоритма следует, что A = O(nlogn), M = O(nlogn). Покажем, что в конце работы алгоритма F и R остовные деревья кратчайших путей. По условию конца работы для каждой вершины xe V будет D'(x) = d"(x), и ExeV D+(x) = ExeV D"(x). Из описания алгоритма следует, что для каждой дуги y—i—Kx, учтенной в D (x), yeV. Поэтому условие конца работы может быть выполнено только в том случае, когда D(x) = d+(x) и V = V(G). Тем самым, в конце работы алгоритма деревья F и R остовные. Кроме того, для каждой дуги y—i—x корень получит такой «Ответ» от x, что q = true и y—i—xeH(x). В этот момент времени xeV, а в H(x) существует путь, начинающийся в корне, последняя дуга которого - это дуга y—i—x. Это значит, что каждая дуга графа участвует в коррекции деревьев F и R. Следовательно, по утверждениям в 5.1 и 5.2 F и R деревья кратчайших путей.
8. Алгоритмы построения отображения
Мы рассмотрим два алгоритма построения отображения f которое для каждой вершины a и каждой другой вершины b ставит в соответствие номер дуги, с которой начинается кратчайший путь из a в b. У этих алгоритмов одинаковые оценки A = O(nlogn) и M = O(nlogn), но разные оценки T и N: в «быстром» алгоритме оценки T = O(n) и N = O(n), в «экономном» алгоритме оценки T = O(n2) и N = O(1).
В каждом из этих алгоритмов размер сообщения M = O(nlogn). Легко модифицировать алгоритмы, чтобы уменьшить оценку M в n раз до O(logn), увеличив в n раз оценку N. Для этого достаточно при передаче сообщения размером O(nlogn) разбивать его на серию из n мини-сообщений размером O(logn) с пометкой последнего мини-сообщения в серии. Эти мини-сообщения посылаются по дуге в одном срабатывании автомата подряд от первого до последнего. Вершина принимает мини-сообщения и сохраняет их в своей памяти, пока не получит последнее в серии мини-сообщение. Аналогично можно уменьшить оценку M до O(1), увеличив в nlogn раз оценку N. Идея алгоритмов заключается в следующем. Сначала применяется один из двух алгоритмов построения в корне описаний прямого F и обратного R деревьев кратчайших путей, а в каждой вершине x - описания In(x) множества входящих дуг. Затем корень организует доставку в каждую вершину x описания деревьев F и R, а из каждой вершины y в каждую вершину x
описания множества входящих дуг In(y). По F и R вершина x строит описание прямого F(x) и обратного R(x) остовов с корнем в x. Получая от вершины y множество In(y), вершина x для каждой дуги из In(y) корректирует деревья F(x) и R(x). В конечном итоге эти деревья станут деревьями кратчайших путей с корнем в x, что позволяет вершине x создать требуемое отображение f
8.1. «Быстрый» алгоритм
Применяется «быстрый» алгоритм построения в корне описаний деревьев F и R (см. п.7.1). Доставка из корня в каждую вершину описания деревьев F и R, а из каждой вершины в каждую вершину описания множества входящих дуг выполняются параллельно.
8.1.1. Начало работы
После выполнения «быстрого» алгоритма построения в корне описаний деревьев корень r создает сообщение «Остовы» с параметрами (F, R, F(r) = F, In(r)), которое посылает по каждой исходящей из корня дуге дерева F. Также корень инициализирует счетчик ce := 0, показывающий число сообщений «Конец», полученных корнем. Предполагается, что в каждой вершине x Ф r имеется счетчик ct(x) числа сообщений «Остовы», полученных вершиной x. Вначале ct(x) = 0.
8.1.2. Сообщение «Остовы», рассылка по дереву F(x)
Параметры сообщения, созданного вершиной x: F, R, F(x), In(x). Вершина z, получив «Остовы», пересылает его дальше по каждой исходящей из z дуге дерева F(x), и увеличивает счетчик ct(z) := ct(z)+1. Далее проверяется, первое ли это сообщение «Остовы», полученное вершиной z. Если ct(z) = 1, вершина z строит по F и R прямое остовное дерево F(z) с корнем в z, корректирует его по каждой дуге из In(z)uIn(x), создает сообщение «Остовы» с параметрами (F, R, F(z), In(z)), и посылает его по каждой исходящей из z дуге дерева F(z). Если ct(z) > 1, вершина z только корректирует F(z) по каждой дуге из In(x). В любом случае вершина z проверяет, получила ли она «Остовы» от всех вершин x Ф z. Если ct(z) = |V|-1, вершина z по дереву F(z) строит требуемое отображение f, создает сообщение «Конец» с параметрами (R, z), которое посылает по исходящей из z дуге дерева R.
8.1.3. Сообщение «Конец», пересылка по дереву R
Параметры сообщения, созданного вершиной x: R, x. Вершина z Ф r, получив «Конец», пересылает его дальше по исходящей из z дуге дерева R. Корень, получая сообщение «Конец», увеличивает счетчик ce := ce+1. Далее проверяется условие конца работы.
8.1.4. Конец алгоритма
Конец работы алгоритма проверяется корнем по условию: ce = |V|-1.
Покажем, что алгоритм заканчивается через конечное время и определим его оценки. «Быстрый» алгоритм построения в корне описаний деревьев имеет оценки Т = 0(п), А = 0(nlogn), М = 0(nlogn), N = 0(п). После этого сообщение «Остовы» рассылкой по прямому дереву Е за время /1 < п-1 дойдет от корня до каждой вершины. Следовательно, каждая вершина х получит первое сообщение «Остовы» за время не более /ь и создаст свое сообщение «Остовы». После этого от каждой вершины х до каждой другой вершины сообщение «Остовы» рассылкой по прямому дереву Е(х) дойдет за время не более /2 < п-1. После этого от каждой вершины до корня сообщение «Конец» пересылкой по обратному дереву К дойдет за время не более /3 < п-1. Тем самым, алгоритм закончится через время Т = 0(п). Из описания алгоритма следует, что А = 0(nlogn), М = 0(nlogn). Каждая вершина создает только одно сообщение «Остовы» и только одно сообщение «Конец». Поэтому N = 0(п). Покажем, что в конце работы алгоритма в каждой вершине г будет создано требуемое отображение /г. Для этого достаточно показать, что прямое дерево Е(г) является деревом кратчайших путей. При получении первого сообщения «Остовы», созданного вершиной х, вершина г получает прямой Е и обратный К остовы. По ним она строит прямой остов Е(г) с корнем в г, который корректируется по дугам из /п(г)и/п(х). Далее до конца работы вершина г получит «Остовы» от каждой вершины у Ф г и у Ф х с параметром \п(у). Тем самым, вершина г получит описание всех дуг графа. Поскольку Е(г) остов, его коррекция по любой дуге графа всегда выполнима. Следовательно, в конце работы Е(г) является деревом кратчайших путей.
8.2. «Экономный» алгоритм
Применяется «экономный» алгоритм построения в корне описания деревьев Е и К (см. п.7.2). Корень организует цикл по всем вершинам. Для каждой вершины х выполняется доставка из корня в х описания деревьев Е и К, а из х в каждую вершину описания множества входящих дуг \п(х).
8.2.1. Начало работы
После выполнения «экономного» алгоритма построения в корне описания деревьев корень проверяет V = 1. Если корень единственная вершина, конец алгоритма. Иначе корень г выбирает любую вершину х Ф г, инициализирует множество вершин SV := {г, х}, создает сообщение «Остовы» с параметрами (х, Е, К, \п(г)), которое посылает по исходящей из корня дуге дерева Е, ведущей в х. Также корень инициализирует счетчик се := 0, показывающий число сообщений «Конец», полученных корнем. Предполагается, что в каждой вершине х Ф г имеется счетчик с/(х) числа сообщений «Дуги», полученных вершиной х, учитывающий также одно сообщение «Остовы» от корня, если вершина х его получала. Вначале с/(х) = 0.
Burdonov I.B., Kossatchev A.S. Directed distributed system: Backtracking problem. Trudy ISP RAN/Proc. ISP RAS, vol. 30, issue 2, 2018, pp. 167-194_
8.2.2. Сообщение «Остовы», пересылка по дереву F
Параметры сообщения: x, F, R, In(r). Вершина z Ф x, получив «Остовы», пересылает его дальше по исходящей из z дуге дерева F, ведущей в x. Когда сообщение «Остовы» получит вершина x, она увеличивает счетчик ci(x) := ci(x)+1, после чего проверяет его. Если ci(x) = 1, вершина x строит по F и R прямое остовное дерево F(x) с корнем в x, и корректирует его по каждой дуге из In(x)uIn(r). Если ci(x) > 1, вершина x только корректирует F(x) по каждой дуге из In(r). В любом случае, если ci(x) = |V|-1, вершина x по дереву F(x) строит требуемое отображение fx. В любом случае вершина x создает сообщение «Дуги» с параметрами (F(x), R, In(x)), и посылает его по каждой исходящей из x дуге дерева F(x).
8.2.3. Сообщение «Дуги», рассылка по прямому дереву F(x)
Параметры сообщения, созданного вершиной x: F(x), R, In(x). Вершина z, получив «Дуги», пересылает его дальше по каждой исходящей из z дуге дерева F(x), увеличивает счетчик ci(z) := ci(z)+1, после чего проверяет его. Если ci(z) = 1, вершина z строит по F и R прямое остовное дерево F(z) с корнем в z, и корректирует его по каждой дуге из In(z)uIn(x). Если ci(z) > 1, вершина z только корректирует F(z) по каждой дуге из In(x). В любом случае, если ci(z) = |V|-1, вершина z по дереву F(z) строит требуемое отображение fz. В любом случае, вершина z создает сообщение «Конец» с параметрами (R, q = true), которое передается сбором по обратному дереву R: если z листовая вершина дерева R, сообщение посылается по исходящей из z дуге дерева R, иначе сообщение не посылается до тех пор, пока вершина z не получит сообщения «Конец» по всем входящим в z дугам дерева R.
8.2.4. Сообщение «Конец», сбор по обратному дереву R
Параметры сообщения: R, q = true. Вершина z Ф r, получив «Конец», пересылает его дальше сбором по обратному дереву R: если z листовая вершина дерева R, сообщение посылается по исходящей из z дуге дерева R, иначе сообщение не посылается до тех пор, пока вершина z не получит сообщения «Конец» по всем входящим в z дугам дерева R. Корень, получая сообщение «Конец», увеличивает счетчик ce := ce+1. Если ce = |In(r)| - число входящих в корень дуг дерева R, проверяется условие конца работы.
8.2.5. Конец алгоритма
Конец работы алгоритма проверяется корнем по условию: SV = V. Если условие не выполнено, корень выбирает любую вершину xeV\SV, добавляет ее во множество вершин SV := SVu{x}, сбрасывает счетчик ce := 0, создает сообщение «Остовы» с параметрами (x, F, R, In(r)), и посылает его по исходящей из корня дуге дерева F, ведущей в x.
Покажем, что алгоритм заканчивается через конечное время и определим его оценки. «Экономный» алгоритм построения в корне описаний деревьев имеет оценки T = O(n2), A = O(nlogn), M = O(nlogn), N = O(1). После этого корень
перебирает все вершины x ф r в цикле, число проходов цикла равно n-1. На каждом проходе цикла сообщение «Остовы» пересылкой по прямому дереву F за время t1 < n-1 дойдет от корня до выбранной вершины x. После этого от вершины x до каждой другой вершины сообщение «Дуги» рассылкой по прямому дереву F(x) дойдет за время не более t2 < n-1. После этого от каждой вершины до корня сообщение «Конец» сбором по обратному дереву R дойдет за время не более t3 < n-1. Тем самым, один проход цикла требует времени t1 + t2 + t3 < 3(n-1), и алгоритм закончится через время T = O(n2). Из описания алгоритма следует, что A = O(nlogn), M = O(nlogn), N = O(1). Покажем, что в конце работы алгоритма в каждой вершине z будет создано требуемое отображение fz. Для этого достаточно показать, что прямое дерево F(z) является деревом кратчайших путей. При получении вершиной z первого сообщения «Остовы» от корня или «Дуги» от вершины x вершина z получает прямой F и обратный R остовы. По ним она строит прямой остов F(z) с корнем в z, который корректируется по дугам из In(z)uIn(r) или In(z)uIn(x). Далее до конца работы вершина z получит «Дуги» от каждой вершины y ф z и y ф r с параметром In(y). Тем самым, вершина z получит описание всех дуг графа. Поскольку F(z) остов, его коррекция по любой дуге графа всегда выполнима. Следовательно, в конце работы F(z) является деревом кратчайших путей.
9. Нижние оценки сложности
Для «быстрого» алгоритма построения отображения оценка T = O(n) не может быть улучшена, поскольку, очевидно, ограничена снизу временем распространения сообщения от одной вершины до другой, т.е. диаметром графа, который может достигать величины n-1. В этом разделе мы докажем, что для «экономного» алгоритма построения отображения оценка T = O(n2) также не может быть улучшена: для алгоритмов построения отображения с оценками A = unlimited, M = unlimited, N = O(1) имеет место T = Q(n2). Нам достаточно доказать, что алгоритм, который строит требуемое отображение fr только в корне r с оценкой N = O(1), имеет оценку T = Q(n2). Произвольный алгоритм будем называть корневым, если на любом графе в конце его работы в памяти корня r построено отображение fr. Оценка N = O(1) означает, что существует такая константа k, что N < k; ее будем считать емкостью дуги.
До сих пор мы говорили о том, что сообщение проходит маршрут «без задержек»: когда вершина принимает сообщение по дуге маршрута, она сразу же посылает сообщение по следующей дуге маршрута, т.е. не дожидаясь каких-либо еще сообщений. Теперь такой маршрут будем называть главным маршрутом сообщения, но нам понадобится более общее понятие маршрута, проходимого сообщением, возможно, с какими-то задержками. Для любого алгоритма будем говорить, что в момент времени t сообщение прошло маршрут как последовательность смежных дуг P = xj—x2—...—xp-—xp, если
существует неубывающая последовательность моментов времени t1 < t 2 < t2 <...< t p-1 < tp <t p = t такая, что для i = 1..p-1 вершина xt послала сообщение по дуге x—xi+1 в момент времени ti, а вершина xi+1 получила это сообщение в момент времени ti+1. Из этого определения следует, что в общем случае сообщение в момент времени t может пройти несколько маршрутов, заканчивающихся в разных вершинах, и в одной вершине могут заканчиваться несколько из этих маршрутов. Это объясняется тем, что сообщения могут «размножаться», когда вершина, получив сообщение, посылает сообщения по нескольким исходящим дугам, и «склеиваться», когда вершина не посылает сообщение, пока не получит несколько сообщений. Будем говорить, что вершина получает сообщение от вершины x, если она получает сообщение, прошедшее маршрут, начинающийся в x. Будем говорить, что алгоритм покрывает дуги графа, если для каждой дуги графа при работе алгоритма есть сообщение, которое проходит маршрут, проходящий по этой дуге и заканчивающийся в корне.
Утверждение 1. Если алгоритм корневой, то он покрывает дуги графа. Доказательство: Допустим противное. Пусть A корневой алгоритм, а G - граф, в котором есть дуга a—j—, и при работе алгоритма A нет сообщения, которое проходит маршрут, проходящий по этой дуге и заканчивающийся в корне. До конца работы алгоритма A корень получал сообщения, маршруты которых -это маршруты, заканчивающиеся в корне. Поэтому корень может определить конец работы алгоритма Д только на основании этих маршрутов, включая номера дуг и номера вершин, через которые проходили эти маршруты, а также полустепени исхода этих вершин. Рассмотрим граф G, который отличается от графа G тем, что добавлена новая вершина b и новая дуга b—1—a, а дуга a—-j— перенаправлена в вершину b, т.е. это дуга a—j—b. Тогда должно быть: bgIm(f.(G)) и belmfr(G )). На обоих графах в алгоритме A корень r получит одинаковые маршруты и, следовательно, будут построены одинаковые отображения в корне, чего быть не может, если алгоритм A корневой. Утверждение доказано.
В алгоритме, не нарушающем емкость дуги к, вершина может посылать сообщение по дуге только в том случае, когда на этой дуге гарантированно меньше к сообщений. При произвольном времени прохождения сообщений по дугам такую гарантию может дать только получение сообщения-подтверждения, прошедшего по этой дуге и далее по циклу вернувшегося в начало дуги. Если вершина послала по дуге несколько сообщений, подтверждать нужно каждую из таких пересылок. Проблема в том, что сообщения могут «размножаться» и «склеиваться».
Опишем формальную модель подтверждения пересылок. Для этого модифицируем алгоритм так, чтобы вершина нумеровала пересылки сообщений по исходящим дугам и учитывала возникающие циклы передачи сообщений. Пересылка задается тройкой (vj,h), где v - номер вершины, j -
номер исходящей из нее дуги, И - номер пересылки из этой вершины. В каждое сообщение т добавляется множество А (да) всех пересылок этого сообщения. В каждую вершину с номером V добавляется максимальный номер Итах(у) пересылки из этой вершины, множество Б(у) всех неподтвержденных пересылок из этой вершины, а также множество А^) пересылок из сообщений, принятых этой вершиной после отправки ею последнего сообщения. Вначале Итшх{у) = 0, Б(у) = 0, А^) = 0. Можно считать, что в корне эти переменные инициализируются в начале работы, а в любой другой вершине при получении первого сообщения. Когда вершина с номером V посылает сообщение т по дуге с номером у, она увеличивает номер неподтвержденной пересылки: Итах(у) := Итшх^)+1, запоминает эту пересылку как неподтвержденную Б^) := Б^) и { (V,у, Итах(у)) }, добавляет ее в сообщение А(т) := А^) и { (V,у, Итах(V)) }, затем посылает сообщение т по дуге у и «забывает» пересылки из принятых сообщений А^) := 0. Когда вершина с номером V получает сообщение т, она подтверждает неподтвержденные пересылки, имеющиеся в сообщении, Б(у) := Б(у) \ А(т) и запоминает пересылки из сообщения А^) := А^) и А(т). Будем говорить, что сообщение т является подтверждением в вершине с номером V для исходящей дуги с номером у, если при получении этого сообщения множество { (уу',И)еБ(у) \ И = 1.. } неподтвержденных пересылок по этой дуге уменьшается. Алгоритм не нарушает емкость к дуги с номером у, исходящей из вершины с номером V, тогда и только тогда, когда вершина посылает сообщение по этой дуге только при условии, что число неподтвержденных пересылок по этой дуге меньше емкости дуги: \{ (уу,И)еБ(у) \ И = 1.. }\ < к. Будем говорить, что алгоритм следует правилу подтверждения для емкости дуги к, если вершина, послав по дуге р сообщений и получив q подтверждений, посылает следующее сообщение по этой дуге только при условии р^ < к. Отсюда непосредственно следует следующее утверждение. Утверждение 2. При произвольном времени прохождения сообщений по дугам алгоритм не нарушает емкость дуги к тогда и только тогда, когда алгоритм следует правилу подтверждения для емкости дуги к.
Рассмотрим класс графов О = { Оп \ п > 2 } на рис. 2 со всеми возможными способами нумерации вершин и дуг. Числа, записанные в вершинах на рис. 2 будем называть индексами. Когда мы будем говорить «вершина г», мы будем иметь в виду «вершина с индексом г». Если п-1 >у > I > 1, то будем говорить, что вершина г (с меньшим индексом) расположена правее вершины у, а вершина у (с большим индексом) - левее вершины г. Когда вершина г = 1..п-2 получает сообщение по дуге /+1 —>/, будем говорить, что она получает сообщение слева. Обозначим: v(г) - номер вершины г, ш(г) - номер дуги 0—г.
Fig. 2. Example graph
Из утверждения 1 следует, что нам достаточно доказать, что алгоритм, не нарушающий емкости дуги к и покрывающий все дуги графа на классе G с емкостью дуг к, имеет оценку T = Q(n2). Из утверждения 2 следует, что нам достаточно рассматривать алгоритмы, которые следуют правилу подтверждения для емкости дуги к. Для оценки времени работы алгоритма будем рассматривать только случай, когда время пересылки единичное: каждое сообщение по каждой дуге пересылается за 1 такт. Итак, нам достаточно доказать, что алгоритм, следующий правилу подтверждения для емкости дуги к и покрывающий все дуги графа на классе G с емкостью дуг к и единичным временем пересылки, имеет оценку T = Q(n2). Далее по умолчанию мы будем рассматривать только такие алгоритмы. Через t(n) будем обозначать время работы алгоритма.
Из устройства графа Gn следует, что подтверждением в вершине i Ф 0 является сообщение, которое прошло цикл, т.е. маршрут i—i-1—... —1—0—[...—0—]i, где в квадратные скобки заключена часть маршрута, которая может отсутствовать. Сообщение будем называть {/'}-сообщением, если i Ф 0 - это самая левая из вершин, через которые проходило сообщение. Очевидно, что вершина i получает {/'}-сообщение по дуге 0—i, т.е. от корня. Будем говорить, что в вершине i Ф 0 происходит склейка {/"}-сообщения с {j^-сообщением, где j" > j = i, если первое сообщение, которое посылает вершина i, это {/"}-сообщение. Это происходит либо из-за того, что ранее полученное вершиной {/'}-сообщение ожидает в вершине {/"}-сообщения, либо из-за того, что ранее полученное {/"}-сообщение ожидает в вершине {/'}-сообщения, либо из-за того, что вершина, не получив {/'}-сообщения, получает {/"}-сообщение и посылает его дальше. Во всех случаях будет послано {/"}-сообщение, с которым «склеено» {/'}-сообщение. Будем говорить, что в вершине i Ф 0 происходит склейка {/"}-сообщения с {j^-сообщением, где j' > j > i, если эта вершина посылает (j"}-сообщение тогда, когда она еще не послала {}-сообщение. Это происходит из-за того, что ранее полученное {/'}-сообщение ожидает в вершине i {/'^-сообщения. Будет послано {j^-сообщение, с которым «склеено» {^-сообщение.
вершин графа Оп, чтобы ни в какой вершине г Ф 0 не было склейки сообщений до получения этой вершиной первого подтверждения.
Доказательство: Рассмотрим работу алгоритма на графе Оп при некоторой нумерации вершин и дуг. Выберем самую левую вершину, в которой происходит склейка до получения этой вершиной первого подтверждения, и самую первую по времени склейку. Пусть это будет вершина г Ф 0, и она склеивает {у}-сообщение с {у}-сообщением, где у" > у, в момент времени /. Заметим, что любое сообщение, получаемое вершиной г слева до момента склейки в вершине г, не может быть уже склеено в некоторой вершине х > г. Действительно, поскольку мы выбрали самую левую вершину г, где происходит склейка до получения этой вершиной первого подтверждения, склейка в вершине х должна была происходить после получения вершиной х первого подтверждения. Но в этом случае склеенное сообщение, посланное вершиной х и дошедшее до вершины г, является подтверждением и для вершины г, а этого не может быть по правилу выбора вершины г. Вершина г не может получить слева больше к сообщений до получения вершиной г+1 первого подтверждения. Но если вершина г+1 получает такое подтверждение, а потом посылает сообщение, то это сообщение будет подтверждением и для вершины г. Тем самым, вершина г не может получить слева больше к сообщений до получения вершиной г первого подтверждения. Если бы было у" >у+1, то для некоторого х такого, что у" > х >у, либо {у}-сообщение склеивалось бы с {х}-сообщением в вершине левее г, либо { х}-сообщение склеивалось бы с { у}-сообщением в вершине г до получения ею {у}-сообщения. Поэтому, поскольку каждое сообщение, которое вершина г получает слева, не склеено ни с каким сообщением, и мы выбрали самую первую по времени склейку в вершине г, должно быть у" = у+1. Итак, мы рассматриваем склейку {у+1}-сообщения с {у}-сообщением в вершине г. А поскольку мы выбрали первую по времени склейку, очевидно, у минимально. Поэтому возможны три типа склейки.
1) у = г, вершина г, еще не получив {г}-сообщение, получает {г+1} -сообщение.
2) у = г, вершина г сначала получает {г}-сообщение, но не посылает его дальше, а потом получает {г+1}-сообщение.
3) у > г, вершина г сначала посылает последовательно {х}-сообщения, где х = г.у-1, потом получает {у}-сообщение, но не посылает его дальше, а потом получает { у+1}-сообщение.
Тип 1 (рис. 3). Вершина г, еще не получив {г}-сообщение, получает {г+1}-сообщение. Тогда вершина г+1 получала {г+1}-сообщение (от корня) и посылала его дальше. Поскольку время пересылки единичное, корень посылал сообщение по дуге 0—ш(г+1)—г+1, но не посылал сообщение по дуге 0—ш(г)—г или послал его позже (иначе оно пришло бы в вершину г раньше).
любого алгоритма можно так подобрать нумерацию дуг и
root
[i+1]-message
indices of vertices^
i+1
i-1
Рис. 3. Склейка сообщений типа 1 Fig. 3. Gluing messages of type 1
Рассмотрим момент времени t0i+1, когда корень посылает сообщение по дуге 0—a(i+1)—i+1. К этому моменту времени корень мог получить сообщения от вершин самого правого отрезка в диапазоне индексов [1..si+1] (если si+1 = 0, диапазон пустой). Должно быть si+1 < i, поскольку в противном случае {/'+1}-сообщение будет подтверждением в вершине i, т.е. к моменту склейки вершина i получит подтверждение. Поэтому, учитывая, что на классе G у всех вершин, кроме корня, полустепень исхода равна 1, можно считать, что корню в момент времени t0i+1 известная следующая информация: /q,,+1=( v(0), <f(0), v(1) , a(1), ..., v(sm), a(sm) ).
Поскольку si+1 < i, если мы поменяем местами номера дуг a(i)-oa(i+1), то информация I0i+1 не изменится, но сообщение от корня будет приходить не в вершину i+1, а в вершину i. Поэтому вершина i сначала получит {/'}-сообщение, а не сообщение слева. После такого изменения нумерации вершин и дуг в вершине i не будет склейки типа 1.
Тип 2 (рис. 4). Вершина i сначала получает {/'}-сообщение, но не посылает его дальше, а потом получает {/'+1}-сообщение. Тогда вершина i+1 получала {/'+1}-сообщение и посылала его дальше.
root ( \ 4 • [i]-message
r • [i+1]-message i-1
indices of vertices > /+1 i
Рис. 4. Склейка сообщений типа 2 Fig. 4. Gluing messages of type 2
Рассмотрим моменты времени t0,i+1 (to,i), когда корень посылает сообщение по дуге 0—a(i+1)—i+1 (0—a(i)—i). К моменту времени t0i+1 (to,i) корень мог получить сообщения от вершин самого правого отрезка в диапазоне индексов [1..si+1] ([1..si]). Должно быть si+1 < i и st < i, поскольку в противном случае {/'+1}-сообщение или {/'}-сообщение будет подтверждением в вершине i, т.е. к
моменту склейки вершина г получит подтверждение. В моменты времени /0,г+1 и /0,г- корню известна следующая информация: в момент времени /0,1+1: -^,г+1=( v(0), ("(0), v(1), ш(1), ..., v(si+l), а^т) ), в момент времени /0,г: /0г- =( v(0), ¿/"(0), v(1), ш(1), ..., v(sг), а(&\) ). Вершина г+1 (г) получает {г+1}-сообщение ({г}-сообщение) от корня через один такт в момент времени /0,г+1+1 (/0,г+1). Поскольку в вершине г+1 не происходит склейки, а в вершине г не происходит склейки типа 1, это будет первое сообщение, получаемое вершиной. Поэтому в эти моменты времени вершинам известна следующая информация:
для вершины г+1: =( v(0), ((0), v(1), ш(1), ..., v(sm), v(г+1), ш(г+1) ),
для вершины г: =( v(0), С(0), v(1), ш(1), ..., v(sг■), а^), v(г), ш(г), ).
Поскольку < г и • < г, если мы поменяем местами номера вершин v(г)^v(г+1) и номера дуг ш(г)^ш(г+1), то информация в корне /0,г+1 и 10,г не изменится, но сообщение от корня будет приходить не в вершину г+1, а в вершину г. Поэтому информация для вершин г и г+1 поменяется местами !г+1,г+1^ . Поэтому теперь первое сообщение, которое получит вершина г, будет {г}-сообщением, и оно сразу посылается дальше. После такого изменения нумерации вершин и дуг в вершине г не будет склейки типа 1 и 2.
Тип 3 (рис. 5). Вершина г сначала посылает последовательно {х}-сообщения, где х = г.у-1, потом получает {у}-сообщение, но не посылает его дальше, а потом получает { у+1}-сообщение.
root
—И [i]-
/ / ^ r -И- —и j-1]-
/ *-►< • Ul-
Jt-И-►< -... - • [/+1]-
indices of vertices^ J+1 J J- 1 i i-1
Рис. 5.Склейка сообщений типа 3 Fig. 5. Gluing messages of type 3
Для y = i.j+1 вершина y получала и посылала {у}-сообщение. Рассмотрим момент времени t0y, когда корень посылает сообщение по дуге 0—a(y)^y. К этому моменту времени корень мог получить сообщения от вершин самого правого отрезка в диапазоне индексов [1..sy]. Должно быть sy < i, поскольку в противном случае {у}-сообщение будет подтверждением в вершине i, т.е. к моменту склейки вершина i получит подтверждение. В момент времени t0y корню известна следующая информация:
Ioy=( v(0),<f(0), v(1),a(1),..., v(Sy), a(Sy)),
Вершина y получает {у}-сообщение (от корня) через один такт в момент времени t0y+1. Поскольку в вершине y > i не происходит склейки, а в вершине y = i не происходит склейки типа 1 и 2, это будет первое сообщение, получаемое вершиной y. Поэтому в момент времени t0y+1 вершине y известна следующая информация:
Iyy=( v(0), d"(0), v(1), a(1),..., v(sy), a(sy) , v(y), a(y)).
Теперь рассмотрим момент времени tyj, когда вершина y = i..j получает {/}-сообщение. Это сообщение проходит маршрут от вершины j до вершины y, поэтому в момент времени ty,j вершине y известна следующая информация: Iyj =( v(0), d"(0), v(1), a(1),..., v(symax),a(symax) , v(y), a(y), ..., v(j),a(j) ), где syma = max{ s/, ..., sy }.
Поскольку sy < i, если мы поменяем местами номера вершин по циклу v(j+1)^v(j)^...^v(i)^v(j+1) и номера дуг по циклу a(j+1)^a(j)^...^a(i)^a(j+1), то информация в корне I0,y не изменится для каждого y = i.j+1, но сообщение от корня будет приходить не в вершину y > i, а в вершину y-1, и не в вершину y = i, а в вершину j+1. Поэтому в момент времени t0y+1 в вершине y = i.j окажется та информация, которая была в вершине y+1, т.е. I^+i, y+1, а в вершине y = j+1 окажется та информация, которая была в вершине i, т.е. I, i. В результате в момент времени t/ в вершине i окажется та информация, которая была в вершине i+1, т.е. Ii+1j. Поэтому теперь вершина i, получая {у}-сообщение, посылает его дальше. После такого изменения нумерации вершин и дуг в вершине i не будет склейки типа 3 для данного j, а также всех меньших его, поскольку j выбиралось минимальным. Также вершина i, по-прежнему будет получать в качестве первого сообщения {/'}-сообщение и сразу посылать его дальше (как до изменения делала вершина i+1), поэтому в вершине i не будет склеек типов 1 и 2.
Итак, мы нашли такие изменения нумерации дуг и вершин, которые приводят к отсутствию в вершине i склейки типов 1 и 2, а также к отсутствию склейки типа 3 или к увеличению минимального j для типа 3. Поскольку число вершин конечно, мы можем повторять эти изменения до тех пор, пока при работе данного алгоритма не останется склеек. Утверждение доказано. Утверждение 4. Время работы алгоритма на графе Gn равно Q(w2). Доказательство: По утверждению 3 можно считать, что в вершине i = 1..n-1 не происходит склеек сообщений до получения этой вершиной первого подтверждения. Очевидно, корень получит {1}-сообщение через t1 > 2 такта. Обозначим x1 = 1. Пусть вершина Xj посылает 1 < у/ < к сообщений до того, как она перестает посылать сообщения и начинает ждать первого подтверждения. Обозначим xj+1 = Xj+y, тогда xj+1 < Xj+k. Если xj+1 < n-1, то, поскольку склеек нет, {xj+^-сообщение не может быть послано из вершины xj до получения ею первого подтверждения. Обозначим через tj время от начала работы, через которое корень получает {x^-сообщение. Только после этого не менее чем
через 1 такт вершина ху получит подтверждение, и только после этого {ху+1}-сообщение может пройти путь до корня длиной не менее Следовательно, > ¿у + 1 + Имеем:
х! = 1, ¿1 > 2,
х^ + 1 < х2 < х!+к, /2 > ¿1 + 1 + хь
х2+1 < х3 < х2+к, /3 > /2 + 1 + х2,
х„-1+1 < хи < хи-1+к, ¿и > 4-1 + 1 + хи-1.
Тогда г < х, и хи < 1+к(и-1). Пусть п > к + 1. Выберем и максимальное так, чтобы оставаться в диапазоне индексов, т.е. 0 < п-1-к < хи < п-1. Тогда п-1-к < 1+к(и-1), что влечет и > (п-2)/к. Очевидно, ¿(п) > ¿и. Имеем: ¿(п) > 2 + (1+х0 + (1+х2) + (1+х3) + ... + (1+хи) = 2 + и + (х!+х2+х3+...+хи) >
> 2 + и + (1+2+3+...+и) = 2 + и + и(и+1)/2 = 2+и(и+3)/2 >
> 2+((п-2)/к)(((п-2)/к)+3)/2 = (п-2)2/(2к2)+3(п-2)/2к+2 > п2/(3кг) = ^(п2). Утверждение доказано.
10. Синхронная модель
До сих пор мы рассматривали асинхронную модель, в которой время пересылки сообщения по дуге может быть произвольным в диапазоне [0..1] и даже меняться со временем. В синхронной модели время пересылки считается равным 1 такту и не меняется. В то же время следует отметить, что под синхронной моделью понимается не просто модель с единичным временем пересылки, а с дополнительным свойством: вершина принимает сразу все сообщения, дошедшие до нее по входящим дугам. Это соответствует понятию раунда как единицы измерения времени. За один раунд каждая вершина принимает все пришедшие к ней по входящим дугам сообщения и посылает все сообщения по исходящим из нее дугам.
Такой режим работы можно симулировать в модели, где вершина за одно «срабатывание» принимает только одно сообщение, если вместе с сообщением вершина получает булевский признак «последнего сообщения», указывающий, является ли это сообщение последним или не последним из сообщений, дошедших до вершины и еще не принятых ею. «Быстрый» алгоритм построения отображения (см. 8.1) легко модифицируется в синхронной модели так, что получаются оценки Т = О(п), А = O(n2logn), М = O(n2logn), N = 1. Для этого достаточно, чтобы вершина принимала сообщения до тех пор, пока не получит сообщение с признаком «последнее сообщение». Если в оригинальном алгоритме, приняв сообщение т, вершина должна была послать по дуге у сообщение т\ то в модифицированном алгоритме сообщение не посылается, а в памяти вершины запоминается пара (т\у). После получения сообщения с признаком «последнее сообщение» по
каждой дуге j посылается не более чем одно сообщение, склеенное из тех сообщений m \ которые были запомнены в паре с дугой j. При единичном времени пересылки все сообщения, посланные в вершину на предыдущем раунде, одновременно доходят до вершины на следующем раунде через 1 такт, время между приемом первого и последнего из этих сообщений равно нулю, и по каждой исходящей дуге посылается не более одного сообщения. Поэтому N = 1, и сохраняется оценка T = O(n). Остальные оценки увеличиваются не более чем в n раз: A = O(n2logn), M = O(n2logn), что объясняется необходимостью хранить в памяти вершины несколько (но не более n) сообщений и склеивать из нескольких (но не более n) сообщений одно сообщение. Более точно, в оригинальном алгоритме на одной дуге может оказаться не более одного сообщения каждого типа от одной вершины, а число типов ограничено. Таким образом, в модифицированном алгоритме в вершине дополнительно хранятся оригинальные сообщения не более чем от n вершин с ограниченным числом сообщений от каждой из них, а «склеенное» сообщение состоит из оригинальных сообщений не более чем от n вершин с ограниченным числом сообщений от каждой из них. Поскольку в оригинальном алгоритме A = O(nlogn) и M = O(nlogn), в модифицированном алгоритме получаются оценки A = O(n2logn) и M = O(n2logn). Другим способом симуляции синхронной работы является сигнал «освобождение дуги j», который вершина получает, когда на дуге j не остается сообщений, не дошедших до конца дуги. В этом случае вершина, принимая сообщения, не посылает сообщение по дуге j до тех пор, пока не получит сигнал «освобождение дуги j». Возможно также, что имеется только общий сигнал «освобождение всех исходящих дуг» [7]. Для соответствующей модификации «быстрого» алгоритма построения отображения при единичном времени пересылки получаем такие же оценки T = O(n), A = O(n2logn), M = O(n2logn), N = 1. Более того, эти оценки остаются верными для произвольного и даже меняющегося времени пересылки в диапазоне [0..1]. В этом случае время ожидания между приемом сообщения вершиной и его посылкой по исходящей дуге не превышает времени пересылки по этой дуге, т.е. 1 такта, что ведет к увеличению времени T не более чем в 2 раза.
11. Заключение
В разд. 8 для асинхронной модели распределенной системы предложены два алгоритма построения отображения, позволяющего пересылать сообщения между вершинами по кратчайшим путям. «Быстрый» алгоритм имеет оценки T = O(n), A = O(nlogn), M = O(nlogn), N = O(n), «экономный» алгоритм имеет оценки T = O(n2), A = O(nlogn), M = O(nlogn), N = O(1). В разд. 9 доказано, что при таких оценках числа N одновременно передаваемых по дуге сообщений оценки времени T не улучшаемы при неограниченных размерах памяти вершин и сообщений: T = ©(n) при N = O(n) и T = ©(n2) при N = O(1).
В разд. 10 показано, как «быстрый» алгоритм можно модифицировать для синхронной модели при условии, что имеется либо признак «последнее сообщение», либо сигнал «освобождение дуги j» или «освобождение всех исходящих дуг». В этом случае T = O(n), A = 0(n2logn), M = 0(n2logn), N = 1. В то же время, если время пересылки равно 1 такту и не меняется, но признака «последнее сообщение» и сигналов «освобождение дуги j» или «освобождение всех исходящих дуг» нет, вопрос об оценке времени работы алгоритма с ограниченной емкостью дуги N = 0(1) остается открытым. Другое направление дальнейших исследований - это поиск эффективных алгоритмов решения задач на ориентированных графах, не сводимых к симуляции алгоритмов для неориентированной распределенной системы.
Список литературы
[1]. Y. Afek and E. Gafni, Distributed Algorithms for Unidirectional Networks, SIAM J. Comput., vol. 23, No. 6, 1994, pp. 1152-1178.
[2]. И.Б.Бурдонов. Обход неизвестного ориентированного графа конечным роботом. Программирование, 2004, №4, стр.11-34.
[3]. И.Б.Бурдонов. Проблема отката по дереву при обходе неизвестного ориентированного графа конечным роботом. Программирование, 2004, №6, стр.629.
[4]. И. Бурдонов, А. Косачев. Общий подход к решению задач на графах коллективом автоматов. Труды Института системного программирования РАН, том 29, вып. 2, 2017 г., стр. 27-76. DOI: 10.15514/ISPRAS-2017-29(2)-2.
[5]. И. Бурдонов, А. Косачев. Распределённые алгоритмы на корневых неориентированных графах. Труды Института системного программирования РАН, том 29, вып. 5, 2017 г., стр. 283-310. DOI: 10.15514/ISPRAS-2017-29(5)-14.
[6]. И. Бурдонов, А. Косачев. Размер памяти для хранения упорядоченного корневого графа. Труды Института системного программирования РАН, том 29, вып. 2, 2017 г., стр. 7-26. DOI: 10.15514/ISPRAS-2017-29(2)-1.
[7]. И.Б. Бурдонов, А.С. Косачев, В.В. Кулямин. Параллельные вычисления на графе. Программирование, 2015, №1, стр. 3-20.
Directed distributed system: Backtracking problem
I.B. Burdonov <[email protected]> A.S. Kossatchev <[email protected]> Institute for System Programming of the Russian Academy of Sciences, 25, Alexander Solzhenitsyn st., Moscow, 109004, Russia.
Abstract. For a distributed system based on a directed graph without multiple edges and loops, the backtracing problem is considered: how to transfer a message from the final vertex of the arc to its initial vertex. The task is to create a structure on the graph that allows the message to be transmitted from the final vertex of the arc to its initial vertex in the minimum time, i.e. on the shortest path. Such a structure at each vertex a is given by mapping the number of vertex b to the number of the outgoing arc through which the shortest path passes from a to b. In particular, such a mapping makes it possible to simulate, in directed
193
distributed systems, algorithms for solving problems on a graph, developed for unditected distributed systems. This increases the running time of such algorithms by not more than k times, where k does not exceed the diameter of the graph, k <n, where n is the number of vertices of the graph. Section 2 describes the asynchronous model of the distributed system used. Section 3 contains the basic definitions and notation, and Section 4 - the statement of the problem. Section 5 describes two auxiliary algorithms for subtree correction, the application of which makes it possible to construct spanning trees of shortest paths: a out-tree and an in-tree. Section 6 contains a description of the various methods for transmitting messages over the graph. In Section 7, two algorithms are proposed for constructing in the memory of the graph root automaton the descriptions of spanning out- and in- shortest path trees, and in Section 8, the algorithms for constructing the required mapping based on them: a "fast" algorithm with T = O(n) and N = O(n) and an "economical" algorithm with T = O(n2) and N = O(1), where T is the running time of the algorithm, N is the number of messages simultaneously transmitted along the arc. In Section 9 it is proved that these estimates of time are not improved. In Section 10, the "fast" algorithm is modified for a synchronous model with N = 1. The conclusion sums up and outlines directions for further research.
Keywords: directed graph; rooted graph; numbered graph; distributed algorithms; graph problems; backtracing problem; shortest paths.
DOI: 10.15514/ISPRAS-2018-30(2)-9
For citation: Burdonov I.B., Kossatchev A.S. Directed distributed system: Backtracking problem. Trudy ISP RAN/Proc. ISP RAS, vol. 30, issue. 2, 2018, pp. 167-194 (in Russian). DOI: 10.15514/ISPRAS-2018-30(2)-9
References
[1]. Y. Afek and E. Gafni, Distributed Algorithms for Unidirectional Networks, SIAM J. Comput., Vol. 23, No. 6, 1994, pp. 1152-1178.
[2]. I.B.Bourdonov. Traversal of an Unknown Directed Graph by a Finite Robot. Programming and Computer Software, vol. 30, No. 4, 2004, pp. 188-203.
[3]. I.B.Bourdonov. Backtracking Problem in the Traversal of an Unknown Directed Graph by a Finite Robot. Programming and Computer Software, vol. 30, No. 4, 2004, pp. 305322.
[4]. I.Burdonov, A.Kossatchev. General approach to solving problems on graphs by collective automata. Trudy ISP RAN/Proc. ISP RAS, vol. 29, issue 2, 2017, pp. 27-76 (in Russian). DOI: 10.15514/ISPRAS-2017-29(2)-2.
[5]. I.Burdonov, A.Kossatchev. Distributed algorithms on root undirected graphs. Trudy ISP RAN/Proc. ISP RAS, vol. 29, issue 5, 2017, pp. 283-310 (in Russian). DOI: 10.15514/ISPRAS-2017-29(5)-14.
[6]. I.Burdonov, A.Kossatchev. The size of the memory for storing the ordered root graph. Trudy ISP RAN/Proc. ISP RAS, vol. 29, issue 2, 2017, pp. 7-26 (in Russian). DOI: 10.15514/ISPRAS-2017-29(2)-1.
[7]. I.B. Burdonov, A.S. Kossatchev, V.V. Kulyamin. Parallel Computations on a Graph. Programming and Computer Software, vol. 41, No. 1, 2015, pp. 1-13. DOI: 10.1134/S0361768815010028.
