Алговики - Вклад [ru]

MediaWiki:Sitenotice

2025-11-21T18:48:56Z

Apaokin: Полностью удалено содержимое страницы

MediaWiki:Sitenotice

2025-11-18T10:55:08Z

Apaokin:

<p style="font-size: 20px;" class="text-danger">В связи с обновлением сайта все изменения, сделанные участниками с 21 ноября 15 часов до конца обновления, не будут включены в новую версию. AlgoWiki будет снова функционировать в обычном режиме после исчезновения данного сообщения, скорее всего, в субботу,22 ноября.</p>

MediaWiki:Sitenotice

2025-11-18T10:49:43Z

Apaokin:

MediaWiki:Sitenotice

2025-11-18T10:48:32Z

Apaokin: Новая страница: «<p style="font-size: 20px;" class="text-danger">В связи с переездом проекта, все изменения, сделанные участник...»

<p style="font-size: 20px;" class="text-danger">В связи с переездом проекта, все изменения, сделанные участниками с 21 ноября 15 часов до конца переезда, не будут включены в новую версию. Algowiki будет снова функционировать в обычном режиме после исчезновения данного сообщения, скорее всего, в субботу.</p>

Алговики:Тест

2025-11-06T04:19:21Z

Apaokin: Новая страница: «тест»

тест

MediaWiki:Common.js

2022-06-07T15:25:48Z

Apaokin:

/* Размещённый здесь код JavaScript будет загружаться пользователям при обращении к каждой странице */

(function () {

var google_tag = ' <script async src="https://www.googletagmanager.com/gtag/js?id=UA-60413267-1"></script> <script> window.dataLayer = window.dataLayer || []; function gtag(){dataLayer.push(arguments);} gtag("js", new Date()); gtag("config", "UA-60413267-1"); </script>';

$('head').prepend(google_tag);

$('head').append("<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script> <link rel='stylesheet' type='text/css' href='http://www.x3dom.org/download/x3dom.css'></link>");

// $('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><box></box></shape></scene></x3d>");

$('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><appearance><material diffuseColor='1 0 0'></material></appearance><box></box></shape><transform translation='-3 0 0'><shape><appearance><material diffuseColor='0 1 0'></material></appearance><cone></cone></shape></transform><transform translation='3 0 0'><shape><appearance><material diffuseColor='0 0 1'></material></appearance><sphere></sphere></shape></transform></scene></x3d>");

}());

MediaWiki:Common.js

2022-06-07T15:16:12Z

Apaokin:

/* Размещённый здесь код JavaScript будет загружаться пользователям при обращении к каждой странице */

(function () {

var google_tag = '
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-60413267-1"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag("js", new Date());

gtag("config", "UA-60413267-1");
</script>';

$('head').prepend(google_tag);

$('head').append("<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script> <link rel='stylesheet' type='text/css' href='http://www.x3dom.org/download/x3dom.css'></link>");

// $('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><box></box></shape></scene></x3d>");

$('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><appearance><material diffuseColor='1 0 0'></material></appearance><box></box></shape><transform translation='-3 0 0'><shape><appearance><material diffuseColor='0 1 0'></material></appearance><cone></cone></shape></transform><transform translation='3 0 0'><shape><appearance><material diffuseColor='0 0 1'></material></appearance><sphere></sphere></shape></transform></scene></x3d>");

}());

MediaWiki:Common.js

2022-06-07T15:11:26Z

Apaokin:

/* Размещённый здесь код JavaScript будет загружаться пользователям при обращении к каждой странице */

(function () {

var google_tag = `
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-60413267-1"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());

gtag('config', 'UA-60413267-1');
</script>`;

$('head').prepend(google_tag);

$('head').append("<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script> <link rel='stylesheet' type='text/css' href='http://www.x3dom.org/download/x3dom.css'></link>");

// $('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><box></box></shape></scene></x3d>");

$('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><appearance><material diffuseColor='1 0 0'></material></appearance><box></box></shape><transform translation='-3 0 0'><shape><appearance><material diffuseColor='0 1 0'></material></appearance><cone></cone></shape></transform><transform translation='3 0 0'><shape><appearance><material diffuseColor='0 0 1'></material></appearance><sphere></sphere></shape></transform></scene></x3d>");

}());

MediaWiki:Common.js

2022-06-07T15:09:50Z

Apaokin:

/* Размещённый здесь код JavaScript будет загружаться пользователям при обращении к каждой странице */

(function () {

var google_tag = "
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-60413267-1"></script>
<script>
window.dataLayer = window.dataLayer || [];
function gtag(){dataLayer.push(arguments);}
gtag('js', new Date());

gtag('config', 'UA-60413267-1');
</script>";

$('head').prepend(google_tag);

$('head').append("<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script> <link rel='stylesheet' type='text/css' href='http://www.x3dom.org/download/x3dom.css'></link>");

// $('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><box></box></shape></scene></x3d>");

$('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><appearance><material diffuseColor='1 0 0'></material></appearance><box></box></shape><transform translation='-3 0 0'><shape><appearance><material diffuseColor='0 1 0'></material></appearance><cone></cone></shape></transform><transform translation='3 0 0'><shape><appearance><material diffuseColor='0 0 1'></material></appearance><sphere></sphere></shape></transform></scene></x3d>");

}());

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-19T14:50:07Z

Apaokin:

{{level-p}}
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>. {{#linktop:Поиск в ширину (BFS)}}
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>. {{#linktop:Алгоритм Дейкстры}}
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>. {{#linktop:Алгоритм Беллмана-Форда}}
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>. {{#linktop:Алгоритм Δ-шагания}}
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Алгоритм Шилоаха-Вишкина поиска компонент связности

2018-06-19T12:04:55Z

Apaokin:

{{algorithm
| name = Алгоритм Шилоаха-Вишкина
| serial_complexity = <math>O((m + n) \ln n)</math>
| pf_height = <math>O(\ln n)</math>
| pf_width = <math>n + 2m</math>
| input_data = <math>O(m)</math>
| output_data = <math>n</math>
}}

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Шилоаха-Вишкина'''<ref>Shiloach, Yossi, and Uzi Vishkin. “An <math>O(\log n)</math> Parallel Connectivity Algorithm.” Journal of Algorithms 3, no. 1 (March 1982): 57–67. doi:10.1016/0196-6774(82)90008-6.</ref> (англ. Shiloach-Vishking Algorithm) предназначен [[Связность в графах|для поиска компонент связности]] неориентированного графа. Используется структура данных, аналогичная [[Система непересекающихся множеств|системе непресекающихся множеств]]. В модели CRCW PRAM алгоритм приписывает каждой вершине идентификатор компоненты связности за время <math>O(\ln n)</math> на <math>n + 2m</math> процессорах.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===

Алгоритм изначально параллельный и при последовательной реализации фактически превращается в [[Система непересекающихся множеств|систему непресекающихся множеств]].

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма Шилоаха-Вишкина <math>O((m + n) \ln n)</math>.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Время работы алгоритма составляет <math>O(\ln n)</math> на <math>n + 2m</math> процессорах в модели CRCW PRAM.

=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
== Литература ==
<references />

[[Категория:Начатые статьи]]

[[en:Shiloach-Vishkin algorithm for finding the connected components]]

Построение минимального остовного дерева (MST)

2018-06-19T11:54:56Z

Apaokin:

{{level-p}}

== Постановка задачи ==

Пусть задан связный неориентированный граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math>. Подграф, являющийся деревом и проходящий через все вершины
<math>G</math>, называется ''основным деревом''. Остовное дерево называется ''минимальным'', если суммарный вес его рёбер является минимальным среди всех остовных
деревьев.

Постановка задачи и алгоритм её решения были впервые опубликованы в работе Отакара Борувки<ref name=boruvka>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref>. Английское название задачи – Minimum Spanning Tree (MST).

== Варианты задачи ==

Если исходный граф <math>G</math> несвязный, то набор минимальных остовных деревьев для всех компонент связности называется ''минимальным остовным лесом'' (Minimum
Spanning Forest, MSF).

Для графа с целочисленными весами возможно использование специальных приёмов, таких как [[wikipedia:ru:Поразрядная сортировка|поразрядная сортировка]], что приводит к
алгоритмам, решающим задачу за линейное время.

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

== Свойства задачи ==

'''Веса'''. Решение задачи зависит не от значений весов, а от их порядка. Таким образом, вместо задания весов можно задать порядок – предикат «меньше или равно» на множестве пар рёбер графа. По этой причине можно без ограничения общности считать, что все веса рёбер различны – для этого следует упорядочить рёбра вначале по весу, а затем по номеру. Кроме того, к исходным весам можно применить любую возрастающую функцию и это не приведёт к изменению решения. Как следствие, можно считать, что все веса находятся в заданном интервале, например, <math>[0, 1]</math>.

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

'''Схлопывание фрагментов'''. Пусть <math>F</math> – фрагмент минимального остовного дерева графа <math>G</math>, а граф <math>G'</math> получен из <math>G</math> склеиванием вершин, принадлежащих
<math>F</math>. Тогда объединение <math>F</math> и минимального остовного дерева графа <math>G'</math> даёт минимальное остовное дерево исходного графа <math>G</math>.

'''Минимальное ребро фрагмента'''. Пусть <math>F</math> – фрагмент минимального остовного дерева и <math>e_F</math> – ребро наименьшего веса, исходящее из <math>F</math> (т.е. ровно один его конец является вершиной из <math>F</math>). Если ребро <math>e_F</math> единственно, то оно принадлежит минимальному остовному дереву. На этом свойстве основаны [[алгоритм Борувки]] и [[алгоритм Прима]].

'''Минимальное ребро графа'''. Если <math>e^*</math> – единственное ребро графа с минимальным весом, то оно принадлежит минимальному остовному дереву. На этом свойстве основан [[алгоритм Крускала]].

'''Ассоциативность по рёбрам'''. Пусть <math>MSF(E)</math> – минимальный остовный лес графа с рёбрами <math>E</math>. Тогда

:<math>
MSF(E_1 \cup E_2 \cup \dots \cup E_k) = MSF(MSF(E_1) \cup MSF(E_2) \cup \dots \cup MSF(E_k)).
</math>

'''Количество рёбер''' остовного леса для графа с <math>n</math> вершинами и <math>c</math> компонентами связности равно <math>n-c</math>. Это свойство может использоваться для более быстрого завершения работы алгоритмов, если число компонент связности известно заранее.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j},
v^{(2)}_{j})</math> с весами <math>f_j</math>).

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''': список рёбер минимального остовного дерева (для несвязного графа – список минимальных остовных деревьев для всех компонент связности).

'''Объём выходных данных''': <math>O(n)</math>.

== Алгоритмы решения задачи ==

Существует три классических подхода к решению задачи:
* '''[[Алгоритм Борувки]]''';<ref name=boruvka /><ref>Jarník, Vojtěch. “O Jistém Problému Minimálním (Z Dopisu Panu O. Borůvkovi).” Práce Moravské Přírodovědecké Společnosti 6, no. 4 (1930): 57–63.</ref> {{#linktop: Алгоритм Борувки}}
* '''[[Алгоритм Крускала]]''';<ref>Kruskal, Joseph B. “On the Shortest Spanning Subtree of a Graph and the Traveling Salesman Problem.” Proceedings of the American Mathematical Society 7, no. 1 (January 1956): 48–50. doi:10.1090/S0002-9939-1956-0078686-7.</ref>
* '''[[Алгоритм Прима]]'''.<ref>Prim, R C. “Shortest Connection Networks and Some Generalizations.” Bell System Technical Journal 36, no. 6 (November 1957): 1389–1401. doi:10.1002/j.1538-7305.1957.tb01515.x.</ref><ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref>
Во всех случаях последовательная сложность алгоритма <math>O(m \ln m)</math> при использовании обычных структур данных. (Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин.)

Все другие алгоритмы, как правило, являются вариацией на тему одного из трёх перечисленных, или их комбинацией.
* '''[[Алгоритм GHS]]''' (Gallager, Humblet, Spira)<ref>Gallager, Robert G, P A Humblet, and P M Spira. “A Distributed Algorithm for Minimum-Weight Spanning Trees.” ACM Transactions on Programming Languages and Systems 5, no. 1 (1983): 66–77. doi:10.1145/357195.357200.</ref> и его последующие версии<ref>Gafni, Eli. “Improvements in the Time Complexity of Two Message-Optimal Election Algorithms,” 175–85, New York, New York, USA: ACM Press, 1985. doi:10.1145/323596.323612.</ref><ref>Awerbuch, B. “Optimal Distributed Algorithms for Minimum Weight Spanning Tree, Counting, Leader Election, and Related Problems,” 230–40, New York, New York, USA: ACM Press, 1987. doi:10.1145/28395.28421.</ref> являются распределённым вариантом алгоритма Борувки. Это алгоритм обычно используется для автоматического распределённого построения остовного дерева сетью коммутаторов.
* '''Алгоритм Габова''' и др.<ref>Gabow, Harold N, Zvi Galil, Thomas H Spencer, and Robert Endre Tarjan. “Efficient Algorithms for Finding Minimum Spanning Trees in Undirected and Directed Graphs.” Combinatorica 6, no. 2 (June 1986): 109–22. doi:10.1007/BF02579168.</ref> использует [[wikipedia:ru:Фибоначчиева куча|фибоначчиеву кучу]] для упорядочения рёбер в алгоритме Борувки. Сложность <math>O(m \ln \beta (m, n))</math>.
* '''Алгоритм Фредмана и Уилларда'''<ref>Fredman, Michael L, and Dan E Willard. “Trans-Dichotomous Algorithms for Minimum Spanning Trees and Shortest Paths.” Journal of Computer and System Sciences 48, no. 3 (June 1994): 533–51. doi:10.1016/S0022-0000(05)80064-9.</ref> предназначен для графов с целочисленными весами и имеет линейную оценку сложности <math>O(m)</math>. Используется алгоритм Прима в сочетании со специально разработанным алгоритмом кучи ([[wikipedia:AF-heap|AF-heap]]).
* '''Алгоритм Каргера''' и др.<ref>Karger, David R, Philip N Klein, and Robert Endre Tarjan. “A Randomized Linear-Time Algorithm to Find Minimum Spanning Trees.” Journal of the ACM 42, no. 2 (March 1, 1995): 321–28. doi:10.1145/201019.201022.</ref> решает задачу ''в среднем'' за линейное время <math>O(m)</math>. (Существование детерминированного алгоритма с линейной оценкой сложности является открытым вопросом.)

Следует отметить, что алгоритмы, имеющие асимптотическую сложность лучшую, чем <math>O(m \ln n)</math>, как правило, на практике работают медленнее классических алгоритмов: константа в оценке настолько велика, что выигрыш от лучшей асимптотике будет заметен только на графах очень больших размеров.

== Ресурс параллелизма ==

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

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-19T11:50:26Z

Apaokin:

{{level-p}}
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>. {{#linktop:Алгоритм Дейкстры}}
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>. {{#linktop:Алгоритм Беллмана-Форда}}
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>. {{#linktop:Алгоритм Δ-шагания}}
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Алгоритм Борувки

2018-06-19T11:42:43Z

Apaokin:

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|E|ln(|V|))</math>
| pf_height = <math>max O(ln(|V|)) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Борувки'''<ref>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref><ref>Jarník, Vojtěch. “O Jistém Problému Minimálním (Z Dopisu Panu O. Borůvkovi).” Práce Moravské Přírodovědecké Společnosti 6, no. 4 (1930): 57–63.</ref> предназначен для решения [[Построение минимального остовного дерева (MST)|задачи о построении минимального остовного дерева]] во взвешенном неориентированном графе. Алгоритм хорошо параллелизуется и является основой для распределённого [[Алгоритм GHS|алгоритма GHS]].

=== Математическое описание алгоритма ===

Пусть задан связный неориентированный граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math>. Предполагается, что веса всех рёбер различны (если это не так, то можно упорядочить рёбра сначала по весу, а потом по номеру).

Алгоритм Борувки основан на следующих двух свойствах задачи:
* '''Минимальное ребро фрагмента'''. Пусть <math>F</math> – фрагмент минимального остовного дерева и <math>e_F</math> – ребро наименьшего веса, исходящее из <math>F</math> (т.е. ровно один его конец является вершиной из <math>F</math>). Если ребро <math>e_F</math> единственно, то оно принадлежит минимальному остовному дереву.
* '''Схлопывание фрагментов'''. Пусть <math>F</math> – фрагмент минимального остовного дерева графа <math>G</math>, а граф <math>G'</math> получен из <math>G</math> склеиванием вершин, принадлежащих <math>F</math>. Тогда объединение <math>F</math> и минимального остовного дерева графа <math>G'</math> даёт минимальное остовное дерево исходного графа <math>G</math>.

В начале работы алгоритма каждая вершина графа <math>G</math> является отдельным фрагментом. На очередном шаге у каждого фрагмента выбирается исходящее ребро минимального веса (если такое ребро существует). Выбранные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты склеиваются.

=== Вычислительное ядро алгоритма ===
Основными операциями являются:
# Поиск минимального по весу исходящего ребра в каждом фрагменте.
# Объединение фрагментов.

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

Классический пример (из статьи Борувки) – спроектировать наиболее дешёвую электрическую сеть, зная стоимость устройства каждого участка электрической линии.

Пусть задан связный граф <math>G=(V,E)</math> с вершинами <math>V = ( v_{1}, v_{2}, ..., v_{n} )</math> и рёбрами <math>E = ( e_{1}, e_{2}, ..., e_{m} )</math>. Каждому ребру <math>e \in E</math> приписан вес <math>w(e)</math>.

Требуется построить дерево <math>T^* \subseteq E</math>, связывающее все вершины и имеющее наименьший возможный вес среди всех таких деревьев:

<math> w(T^* )= \min_T( w(T)) </math>

где вес множества рёбер есть сумма их весов:

<math>w(T)=\sum_{e \in T} (w(T))</math>

Если граф <math>G</math> не является связным, то дерева, связывающего все вершины, не существует.

В этом случае необходимо найти минимальной остовное дерево для каждой компоненты связности <math>G</math>. Набор таких деревьев называется минимальным остовным лесом (сокращённо MSF – Minimum Spanning Forest).

==== Вспомогательный алгоритм: система непересекающихся множеств (Union-Find)====

Во всех алгоритмах решения задачи требуется отслеживать, каким уже построенным фрагментам дерева принадлежат те или иные вершины графа. Для этого используется структура данных «система непересекающихся множеств» (Union-Find). Данная структура поддерживает две операции:

1. <math>FIND(v) = w</math> – по вершине v возвращает вершину w – «корень» фрагмента, которому принадлежит вершина v. При этом гарантируется, что вершины u и v принадлежат одному и тому же фрагменту, тогда и только тогда, когда <math>FIND(u) = FIND(v)</math>.

2. <math>MERGE(u, v)</math> – объединяет два фрагмента, которым принадлежат вершины <math>u</math> и <math>v.</math> (Если они уже лежат в одном фрагменте, то ничего не происходит.) При практической реализации удобно, чтобы данная операция возвращала значение истина, если объединение фрагментов имело место, и ложь в противном случае.

==== Последовательная версия====

Классический последовательный алгоритм Union-Find описан в статье Тарьяна. Каждой вершине v приписывается указатель на вершину-родителя <math>parent(v)</math>.

1. Изначально <math>parent(v) := v</math> для всех вершин.

2. <math>FIND(v)</math> выполняется следующим образом: полагаем <math>u := v</math>, и далее следуем по указателям <math>u := parent(u)</math> до тех пор, пока не станет <math>u = parent(u)</math>. Это и будет результат операции. Дополнительно можно «схлопывать» дерево: присвоить всем посещённым вершинами: <math>parent(u_i) := u</math>, либо производить схлопывание по пути: <math>parent(u) := parent(parent(u)))</math>.

3. <math>MERGE(u, v)</math> выполняется следующим образом: вначале находим корневые вершины <math>u := FIND(u), v := FIND(v)</math>. Если <math>u = v</math>, то исходные вершины принадлежат одному фрагменту и объединения фрагментов не происходит. В противном случае полагаем одно из <math>parent(u) := v</math> или <math>parent(v) := u</math>. Дополнительно можно отслеживать количество вершин в каждом из фрагментов, чтобы меньший фрагмент подсоединять к большему, а не наоборот (оценки сложности доказываются именно при такой реализации, однако на практике алгоритм хорошо работает и без подсчёта количества вершин).

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

1. В самом начале каждая вершина является отдельным фрагментом.

2. На каждом шаге:

* Для каждого фрагмента определяется минимальное по весу исходящее ребро.

* Минимальные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты объединяются.

3. Алгоритм останавливается, когда остаётся только один фрагмент либо когда ни у одного из фрагментов нет исходящих рёбер.

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

Объединение фрагментов также может быть реализовано параллельно с использованием параллельной версии описанного выше алгоритма Union-Find.

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

1. В начале итерации счётчик активных фрагментов обнуляется.

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

3. На этапе объединения фрагментов счётчик уменьшается на единицу каждый раз, когда операция <math>MERGE(u, v)</math> вернула значение истина.

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

=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма Борувки для графа с <math>|V|</math> вершинами и <math>|E|</math> рёбрами составляет <math>O(|E| \ln(|V|))</math> операций.

=== Информационный граф ===

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

'''Нижний уровень параллелизма''': поиск минимальных исходящих рёбер может выполняться независимо для каждого фрагмента, благодаря чему данную стадию вычислений можно эффективно параллелизовать (как на GPU, так и на CPU). Объединение фрагментов также может быть реализовано параллельно с использованием описанного выше алгоритма Union-Find.

'''Верхний уровень параллелизма''': построение отдельных минимальных основных деревьев для каждого из списков ребер может производиться параллельно. Например, список ребер может разбиваться на две части, одна из которых обрабатывается на GPU, а вторая параллельно на CPU.

[[file:MST low.png|thumb|center|1000px|Рисунок 1. Информационный граф нижнего уровня параллелизма]]

Рассмотрим информационные графы и подробное описание каждого из них. Также можно считать, что на рисунке 1 представлен информационный граф классического алгоритма Борувки, а на рисунке 2 — алгоритма обработки графа.

Нижний уровень параллелизма на графе алгоритма (рисунок 1) расположен на уровнях {3, 4, 5}, соответствующих операциям параллельного поиска минимальных исходящих ребер, а также на уровнях {6, 7, 8}, соответствующих операциям параллельного объединения деревьев. Также различные операции копирования {1, 2, 8, 9} выполняются параллельно. После выполнения тела цикла производится проверка {12} того, сколько деревьев осталось на текущем шаге, и если данное число не изменилось, то происходит выход из цикла, иначе переход к следующей итерации.

Верхний уровень параллелизма (рисунок 2), как уже говорилось, заключается в параллельном вычислении минимального остовного дерева (compute mst) для различных частей графа. Перед этим производится процесс инициализации (init process), данные которого используют последующие параллельные операции compute mst. Затем, после параллельных вычислений mst, происходит вычисление итогового основного дерева, после чего полученный результат сохраняется (save results).

[[file:MST up.png|thumb|center|1000px|Рисунок 2. Информационный граф верхнего уровня параллелизма]]

=== Ресурс параллелизма алгоритма ===

Итак, алгоритм Борувки обладает двумя уровнями параллелизма.

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

Кроме того, вычисление каждого из минимальных остовных деревьев (параллельные compute_MST на рисунке 2) обладает внутренним ресурсом параллелизма, описанным далее. Операции инициализации и копирования данных ([1], [2], [9] на рисунке 1) могут производиться параллельно за <math>O(|V|)</math> операций. Также параллельно могут производиться операции поиска минимальных исходящих ребер ([3],[4],[5]), при этом для каждой дуги и обратной к ней независимо, что даёт <math>2*O(|E|)</math> параллельных операций. Помимо этого, операции объединения деревьев [6], [7], [8] могут также производиться параллельно за <math>O(|V|)</math> операций.

В результате для классического алгоритма Борувки ширина ярусно-параллельной формы равна <math>O(|E|)</math>, а высота ЯПФ зависит от числа шагов алгоритма и ограничена сверху <math>O(ln(|V|))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j},
v^{(2)}_{j})</math> с весами <math>f_j</math>).

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''': список рёбер минимального остовного дерева (для несвязного графа – список минимальных остовных деревьев для всех компонент связности).

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма ===
# Алгоритм останавливается за конечное число шагов, поскольку на каждом шаге становится по крайней мере на один фрагмент меньше.
# Более того, число фрагментов на каждом шаге уменьшается как минимум вдвое, так что общее число шагов составляет не более <math>\log_2 n</math>. Отсюда следует и оценка сложности алгоритма.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

На этапе поиска минимального ребра происходят следующие обращения к памяти:
# Чтение информации о рёбрах. Может производиться последовательно.
# Проверка принадлежности ребра одному и тому же фрагменту - два чтения массива <math>parent(u)</math> с вероятным промахом по кэшу.
# Чтение и обновление минимального веса ребра фрагмента. Данная информация может быть закеширована, особенно на поздних шагах, однако обновление необходимо производить атомарно, что требует инвализации кэша.

На этапе схлопывания фрагментов требуется атомарно обновить массив <math>parent(u)</math> для каждого добавляемого в MST ребра. В зависимости от реализации параллельной структуры Union-Find корни фрагментов могут находиться ближе к началу массива, что позволяет закешировать эту наиболее часто читаемую область. Требование атомарности, однако, ограничивает эффект от такого кэширования.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:boruvka_1.png|thumb|center|700px|Рисунок 3. Алгоритм Борувки. Общий профиль обращений в память]]

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

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

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

[[file:boruvka_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 1]]

Далее перейдем к изучению фрагмента 2 (рис. 5). Здесь можно увидеть, что строение каждого из 4 этапов отличается достаточно сильно. Как и в случае с фрагментом 1, каждый следующий этап обладает более высокой локальностью, однако здесь это заметно сильнее. При этом отметим, что данный фрагмент задействует всего около 60 элементов, а обращений к ним выполняется достаточно много, так что локальность в данном случае будет высока.

[[file:boruvka_3.png|thumb|center|700px|Рисунок 5. Профиль обращений, фрагмент 2]]

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

[[file:boruvka_4.png|thumb|center|700px|Рисунок 6. Профиль обращений, фрагмент 3]]

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

[[file:boruvka_5.png|thumb|center|500px|Рисунок 7. Профиль обращений, фрагмент 4]]

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

===== Количественная оценка локальности =====

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

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

[[file:boruvka_daps.png|thumb|center|700px|Рисунок 8. Сравнение значений оценки daps]]

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

1. части, отвечающей за общую координацию вычислений

2. части, отвечающей за параллельные вычисления на многоядерных CPU или GPU.

Описанный выше последовательный алгоритм не может применяться в параллельной программе: в реализации <math>MERGE</math> результаты операций <math>FIND(u)</math> и <math>FIND(v)</math> могут постоянно меняться, что приведёт к race condition. Параллельный вариант алгоритма описан в статье.

1. Каждой вершине v соответствует запись <math>A[v] = { parent, rank }</math>. Изначально <math>A[v] := { v, 0 }</math>.

2. Вспомогательная операция <math>UPDATE(v, rank_v, u, rank_u)</math>:

old := A[v]

if old.parent != v or old.rank != rank_v then return false

new := { u, rank_u }

return CAS(A[v], old, new)

3. Операция <math>FIND(v)</math>:

while v != A[v].parent do
u := A[v].parent
CAS(A[v].parent, u, A[u].parent)
v := A[u].parent
return v

4. Операция UNION(u, v):

while true do
(u, v) := (FIND(u), FIND(v))
if u = v then return false
(rank_u, rank_v) := (A[u].rank, A[v].rank)
if (A[u].rank, u) > (A[v].rank, v) then
swap((u, rank_u), (v, rank_v))
if UPDATE(u, rank_u, v, rank_u) then
if rank_u = rank_v then
UPDATE(v, rank_v, v, rank_v + 1)
return true

Для описанной версии алгоритма гарантируется свойство wait-free. На практике может использоваться упрощённая версия без подсчёта рангов, обладающая более слабым свойством lock-free, но в ряде случаев выигрывающая по скорости.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Борувки согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

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

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера

[[file:MST scaling strong.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма Борувки масштабируемость CPU версии: производительность в зависимости от числа запущенных CPU-потоков.]]

[[file:MST scaling wide.png|thumb|center|700px|Рисунок 4. Параллельная реализация алгоритма Борувки масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Борувки, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Борувки, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Boruvka cpu.png|thumb|center|700px|Рисунок 11. График загрузки CPU при выполнении алгоритма Борувки]]

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

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 12. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

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

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 13. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 14. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов тоже достаточно высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 15. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 17. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Борувки]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]; функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают алгоритм Борувки и [[алгоритм Крускала]].
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] {{Buttonlinkimp|28}}
* RCC for CPU: {{Buttonlinkimp|15}}
* RCC for GPU: {{Buttonlinkimp|13}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Boruvka's algorithm]]

Алгоритм Шилоаха-Вишкина поиска компонент связности

2018-06-19T11:39:51Z

Apaokin:

{{algorithm
| name = Алгоритм Шилоаха-Вишкина
| serial_complexity = <math>O((m + n) \ln n)</math>
| pf_height = <math>O(\ln n)</math>
| pf_width = <math>n + 2m</math>
| input_data = <math>O(m)</math>
| output_data = <math>n</math>
}}

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Шилоаха-Вишкина'''<ref>Shiloach, Yossi, and Uzi Vishkin. “An <math>O(\log n)</math> Parallel Connectivity Algorithm.” Journal of Algorithms 3, no. 1 (March 1982): 57–67. doi:10.1016/0196-6774(82)90008-6.</ref> (англ. Shiloach-Vishking Algorithm) предназначен [[Связность в графах|для поиска компонент связности]] неориентированного графа. Используется структура данных, аналогичная [[Система непересекающихся множеств|системе непресекающихся множеств]]. В модели CRCW PRAM алгоритм приписывает каждой вершине идентификатор компоненты связности за время <math>O(\ln n)</math> на <math>n + 2m</math> процессорах.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===

Алгоритм изначально параллельный и при последовательной реализации фактически превращается в [[Система непересекающихся множеств|систему непресекающихся множеств]].

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма Шилоаха-Вишкина <math>O((m + n) \ln n)</math>.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Время работы алгоритма составляет <math>O(\ln n)</math> на <math>n + 2m</math> процессорах в модели CRCW PRAM.

=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===
* Ligra {{Buttonlinkimp|35}}
* Gap {{Buttonlinkimp|40}}
== Литература ==
<references />

[[Категория:Начатые статьи]]

[[en:Shiloach-Vishkin algorithm for finding the connected components]]

Алгоритм Борувки

2018-06-19T11:32:47Z

Apaokin:

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|E|ln(|V|))</math>
| pf_height = <math>max O(ln(|V|)) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Борувки'''<ref>Borůvka, Otakar. “O Jistém Problému Minimálním.” Práce Moravské Přírodovědecké Společnosti III, no. 3 (1926): 37–58.</ref><ref>Jarník, Vojtěch. “O Jistém Problému Minimálním (Z Dopisu Panu O. Borůvkovi).” Práce Moravské Přírodovědecké Společnosti 6, no. 4 (1930): 57–63.</ref> предназначен для решения [[Построение минимального остовного дерева (MST)|задачи о построении минимального остовного дерева]] во взвешенном неориентированном графе. Алгоритм хорошо параллелизуется и является основой для распределённого [[Алгоритм GHS|алгоритма GHS]].

=== Математическое описание алгоритма ===

Пусть задан связный неориентированный граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math>. Предполагается, что веса всех рёбер различны (если это не так, то можно упорядочить рёбра сначала по весу, а потом по номеру).

Алгоритм Борувки основан на следующих двух свойствах задачи:
* '''Минимальное ребро фрагмента'''. Пусть <math>F</math> – фрагмент минимального остовного дерева и <math>e_F</math> – ребро наименьшего веса, исходящее из <math>F</math> (т.е. ровно один его конец является вершиной из <math>F</math>). Если ребро <math>e_F</math> единственно, то оно принадлежит минимальному остовному дереву.
* '''Схлопывание фрагментов'''. Пусть <math>F</math> – фрагмент минимального остовного дерева графа <math>G</math>, а граф <math>G'</math> получен из <math>G</math> склеиванием вершин, принадлежащих <math>F</math>. Тогда объединение <math>F</math> и минимального остовного дерева графа <math>G'</math> даёт минимальное остовное дерево исходного графа <math>G</math>.

В начале работы алгоритма каждая вершина графа <math>G</math> является отдельным фрагментом. На очередном шаге у каждого фрагмента выбирается исходящее ребро минимального веса (если такое ребро существует). Выбранные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты склеиваются.

=== Вычислительное ядро алгоритма ===
Основными операциями являются:
# Поиск минимального по весу исходящего ребра в каждом фрагменте.
# Объединение фрагментов.

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

Классический пример (из статьи Борувки) – спроектировать наиболее дешёвую электрическую сеть, зная стоимость устройства каждого участка электрической линии.

Пусть задан связный граф <math>G=(V,E)</math> с вершинами <math>V = ( v_{1}, v_{2}, ..., v_{n} )</math> и рёбрами <math>E = ( e_{1}, e_{2}, ..., e_{m} )</math>. Каждому ребру <math>e \in E</math> приписан вес <math>w(e)</math>.

Требуется построить дерево <math>T^* \subseteq E</math>, связывающее все вершины и имеющее наименьший возможный вес среди всех таких деревьев:

<math> w(T^* )= \min_T( w(T)) </math>

где вес множества рёбер есть сумма их весов:

<math>w(T)=\sum_{e \in T} (w(T))</math>

Если граф <math>G</math> не является связным, то дерева, связывающего все вершины, не существует.

В этом случае необходимо найти минимальной остовное дерево для каждой компоненты связности <math>G</math>. Набор таких деревьев называется минимальным остовным лесом (сокращённо MSF – Minimum Spanning Forest).

==== Вспомогательный алгоритм: система непересекающихся множеств (Union-Find)====

Во всех алгоритмах решения задачи требуется отслеживать, каким уже построенным фрагментам дерева принадлежат те или иные вершины графа. Для этого используется структура данных «система непересекающихся множеств» (Union-Find). Данная структура поддерживает две операции:

1. <math>FIND(v) = w</math> – по вершине v возвращает вершину w – «корень» фрагмента, которому принадлежит вершина v. При этом гарантируется, что вершины u и v принадлежат одному и тому же фрагменту, тогда и только тогда, когда <math>FIND(u) = FIND(v)</math>.

2. <math>MERGE(u, v)</math> – объединяет два фрагмента, которым принадлежат вершины <math>u</math> и <math>v.</math> (Если они уже лежат в одном фрагменте, то ничего не происходит.) При практической реализации удобно, чтобы данная операция возвращала значение истина, если объединение фрагментов имело место, и ложь в противном случае.

==== Последовательная версия====

Классический последовательный алгоритм Union-Find описан в статье Тарьяна. Каждой вершине v приписывается указатель на вершину-родителя <math>parent(v)</math>.

1. Изначально <math>parent(v) := v</math> для всех вершин.

2. <math>FIND(v)</math> выполняется следующим образом: полагаем <math>u := v</math>, и далее следуем по указателям <math>u := parent(u)</math> до тех пор, пока не станет <math>u = parent(u)</math>. Это и будет результат операции. Дополнительно можно «схлопывать» дерево: присвоить всем посещённым вершинами: <math>parent(u_i) := u</math>, либо производить схлопывание по пути: <math>parent(u) := parent(parent(u)))</math>.

3. <math>MERGE(u, v)</math> выполняется следующим образом: вначале находим корневые вершины <math>u := FIND(u), v := FIND(v)</math>. Если <math>u = v</math>, то исходные вершины принадлежат одному фрагменту и объединения фрагментов не происходит. В противном случае полагаем одно из <math>parent(u) := v</math> или <math>parent(v) := u</math>. Дополнительно можно отслеживать количество вершин в каждом из фрагментов, чтобы меньший фрагмент подсоединять к большему, а не наоборот (оценки сложности доказываются именно при такой реализации, однако на практике алгоритм хорошо работает и без подсчёта количества вершин).

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

1. В самом начале каждая вершина является отдельным фрагментом.

2. На каждом шаге:

* Для каждого фрагмента определяется минимальное по весу исходящее ребро.

* Минимальные рёбра добавляются в минимальное остовное дерево, а соответствующие фрагменты объединяются.

3. Алгоритм останавливается, когда остаётся только один фрагмент либо когда ни у одного из фрагментов нет исходящих рёбер.

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

Объединение фрагментов также может быть реализовано параллельно с использованием параллельной версии описанного выше алгоритма Union-Find.

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

1. В начале итерации счётчик активных фрагментов обнуляется.

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

3. На этапе объединения фрагментов счётчик уменьшается на единицу каждый раз, когда операция <math>MERGE(u, v)</math> вернула значение истина.

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

=== Последовательная сложность алгоритма ===
Последовательная сложность алгоритма Борувки для графа с <math>|V|</math> вершинами и <math>|E|</math> рёбрами составляет <math>O(|E| \ln(|V|))</math> операций.

=== Информационный граф ===

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

'''Нижний уровень параллелизма''': поиск минимальных исходящих рёбер может выполняться независимо для каждого фрагмента, благодаря чему данную стадию вычислений можно эффективно параллелизовать (как на GPU, так и на CPU). Объединение фрагментов также может быть реализовано параллельно с использованием описанного выше алгоритма Union-Find.

'''Верхний уровень параллелизма''': построение отдельных минимальных основных деревьев для каждого из списков ребер может производиться параллельно. Например, список ребер может разбиваться на две части, одна из которых обрабатывается на GPU, а вторая параллельно на CPU.

[[file:MST low.png|thumb|center|1000px|Рисунок 1. Информационный граф нижнего уровня параллелизма]]

Рассмотрим информационные графы и подробное описание каждого из них. Также можно считать, что на рисунке 1 представлен информационный граф классического алгоритма Борувки, а на рисунке 2 — алгоритма обработки графа.

Нижний уровень параллелизма на графе алгоритма (рисунок 1) расположен на уровнях {3, 4, 5}, соответствующих операциям параллельного поиска минимальных исходящих ребер, а также на уровнях {6, 7, 8}, соответствующих операциям параллельного объединения деревьев. Также различные операции копирования {1, 2, 8, 9} выполняются параллельно. После выполнения тела цикла производится проверка {12} того, сколько деревьев осталось на текущем шаге, и если данное число не изменилось, то происходит выход из цикла, иначе переход к следующей итерации.

Верхний уровень параллелизма (рисунок 2), как уже говорилось, заключается в параллельном вычислении минимального остовного дерева (compute mst) для различных частей графа. Перед этим производится процесс инициализации (init process), данные которого используют последующие параллельные операции compute mst. Затем, после параллельных вычислений mst, происходит вычисление итогового основного дерева, после чего полученный результат сохраняется (save results).

[[file:MST up.png|thumb|center|1000px|Рисунок 2. Информационный граф верхнего уровня параллелизма]]

=== Ресурс параллелизма алгоритма ===

Итак, алгоритм Борувки обладает двумя уровнями параллелизма.

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

Кроме того, вычисление каждого из минимальных остовных деревьев (параллельные compute_MST на рисунке 2) обладает внутренним ресурсом параллелизма, описанным далее. Операции инициализации и копирования данных ([1], [2], [9] на рисунке 1) могут производиться параллельно за <math>O(|V|)</math> операций. Также параллельно могут производиться операции поиска минимальных исходящих ребер ([3],[4],[5]), при этом для каждой дуги и обратной к ней независимо, что даёт <math>2*O(|E|)</math> параллельных операций. Помимо этого, операции объединения деревьев [6], [7], [8] могут также производиться параллельно за <math>O(|V|)</math> операций.

В результате для классического алгоритма Борувки ширина ярусно-параллельной формы равна <math>O(|E|)</math>, а высота ЯПФ зависит от числа шагов алгоритма и ограничена сверху <math>O(ln(|V|))</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j},
v^{(2)}_{j})</math> с весами <math>f_j</math>).

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''': список рёбер минимального остовного дерева (для несвязного графа – список минимальных остовных деревьев для всех компонент связности).

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма ===
# Алгоритм останавливается за конечное число шагов, поскольку на каждом шаге становится по крайней мере на один фрагмент меньше.
# Более того, число фрагментов на каждом шаге уменьшается как минимум вдвое, так что общее число шагов составляет не более <math>\log_2 n</math>. Отсюда следует и оценка сложности алгоритма.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===

=== Локальность данных и вычислений ===

На этапе поиска минимального ребра происходят следующие обращения к памяти:
# Чтение информации о рёбрах. Может производиться последовательно.
# Проверка принадлежности ребра одному и тому же фрагменту - два чтения массива <math>parent(u)</math> с вероятным промахом по кэшу.
# Чтение и обновление минимального веса ребра фрагмента. Данная информация может быть закеширована, особенно на поздних шагах, однако обновление необходимо производить атомарно, что требует инвализации кэша.

На этапе схлопывания фрагментов требуется атомарно обновить массив <math>parent(u)</math> для каждого добавляемого в MST ребра. В зависимости от реализации параллельной структуры Union-Find корни фрагментов могут находиться ближе к началу массива, что позволяет закешировать эту наиболее часто читаемую область. Требование атомарности, однако, ограничивает эффект от такого кэширования.

==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:boruvka_1.png|thumb|center|700px|Рисунок 3. Алгоритм Борувки. Общий профиль обращений в память]]

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

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

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

[[file:boruvka_2.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 1]]

Далее перейдем к изучению фрагмента 2 (рис. 5). Здесь можно увидеть, что строение каждого из 4 этапов отличается достаточно сильно. Как и в случае с фрагментом 1, каждый следующий этап обладает более высокой локальностью, однако здесь это заметно сильнее. При этом отметим, что данный фрагмент задействует всего около 60 элементов, а обращений к ним выполняется достаточно много, так что локальность в данном случае будет высока.

[[file:boruvka_3.png|thumb|center|700px|Рисунок 5. Профиль обращений, фрагмент 2]]

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

[[file:boruvka_4.png|thumb|center|700px|Рисунок 6. Профиль обращений, фрагмент 3]]

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

[[file:boruvka_5.png|thumb|center|500px|Рисунок 7. Профиль обращений, фрагмент 4]]

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

===== Количественная оценка локальности =====

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

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

[[file:boruvka_daps.png|thumb|center|700px|Рисунок 8. Сравнение значений оценки daps]]

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

1. части, отвечающей за общую координацию вычислений

2. части, отвечающей за параллельные вычисления на многоядерных CPU или GPU.

Описанный выше последовательный алгоритм не может применяться в параллельной программе: в реализации <math>MERGE</math> результаты операций <math>FIND(u)</math> и <math>FIND(v)</math> могут постоянно меняться, что приведёт к race condition. Параллельный вариант алгоритма описан в статье.

1. Каждой вершине v соответствует запись <math>A[v] = { parent, rank }</math>. Изначально <math>A[v] := { v, 0 }</math>.

2. Вспомогательная операция <math>UPDATE(v, rank_v, u, rank_u)</math>:

old := A[v]

if old.parent != v or old.rank != rank_v then return false

new := { u, rank_u }

return CAS(A[v], old, new)

3. Операция <math>FIND(v)</math>:

while v != A[v].parent do
u := A[v].parent
CAS(A[v].parent, u, A[u].parent)
v := A[u].parent
return v

4. Операция UNION(u, v):

while true do
(u, v) := (FIND(u), FIND(v))
if u = v then return false
(rank_u, rank_v) := (A[u].rank, A[v].rank)
if (A[u].rank, u) > (A[v].rank, v) then
swap((u, rank_u), (v, rank_v))
if UPDATE(u, rank_u, v, rank_u) then
if rank_u = rank_v then
UPDATE(v, rank_v, v, rank_v + 1)
return true

Для описанной версии алгоритма гарантируется свойство wait-free. На практике может использоваться упрощённая версия без подсчёта рангов, обладающая более слабым свойством lock-free, но в ряде случаев выигрывающая по скорости.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Борувки согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2" [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

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

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера

[[file:MST scaling strong.png|thumb|center|700px|Рисунок 3. Параллельная реализация алгоритма Борувки масштабируемость CPU версии: производительность в зависимости от числа запущенных CPU-потоков.]]

[[file:MST scaling wide.png|thumb|center|700px|Рисунок 4. Параллельная реализация алгоритма Борувки масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Борувки, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Борувки, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Boruvka cpu.png|thumb|center|700px|Рисунок 11. График загрузки CPU при выполнении алгоритма Борувки]]

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

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 12. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

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

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 13. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 14. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов тоже достаточно высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 15. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 17. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Борувки]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]; функции <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#dense-boruvka-minimum-spanning-tree dense_boruvka_minimum_spanning_tree]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-then-merge boruvka_then_merge]</code>, <code>[http://www.boost.org/libs/graph_parallel/doc/html/dehne_gotz_min_spanning_tree.html#boruvka-mixed-merge boruvka_mixed_merge]</code> сочетают алгоритм Борувки и [[алгоритм Крускала]].
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] {{Buttonlinkimp|28}}
* RCC for CPU {{Buttonlinkimp|15}}
* RCC for GPU {{Buttonlinkimp|13}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Boruvka's algorithm]]

Поиск в ширину (BFS)

2018-06-19T11:11:50Z

Apaokin:

{{algorithm
| name = Алгоритм поиска в ширину (BFS)
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A, \max O(|V|) </math>
| pf_width = <math>N/A, \max O(|E|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

Основные авторы описания: [[Участник:Elijah|И.В.Афанасьев]]

== Свойства и структура алгоритма ==

=== Общее описание алгоритма ===

'''Поиск в ширину''' (англ. Breadth-First Search, BFS) позволяет вычислить кратчайшие расстояния (в терминах количества рёбер) от выделенной вершины ориентированного графа до всех остальных вершин, и/или построить корневое направленное дерево, расстояния в котором совпадают с расстояниями в исходном графе. Кроме того, поиск в ширину позволяет решать задачу проверки достижимости (существуют ли пути между вершиной источником и остальными вершинами графа). Впервые алгоритм поиска в ширину описан в работах Мура<ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> и Ли<ref>Lee, C Y. “An Algorithm for Path Connections and Its Applications.” IEEE Transactions on Electronic Computers 10, no. 3 (September 1961): 346–65. doi:10.1109/TEC.1961.5219222.</ref>.

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

В последовательном случае алгоритм имеет алгоритмическую сложность <math>O(|V| + |E|)</math>, где <math>|V|</math> - число вершин в графе, <math>|E|</math> - число ребер в графе.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> без весов, и с выделенной вершиной-источником <math>u</math>. Путем <math>P(u,v)</math> между вершинами <math>u</math> и <math>v</math> называется множество ребер <math>(u, v_1), (v_1, v_2), ... (v_{n-1}, v)</math>. Длиной пути <math>d(u,v)</math> обозначим число ребер в данном пути между вершинами <math>u</math> и <math>v</math>. Поиск в ширину находит кратчайшие пути <math>d(u,v)</math> от вершины <math>u</math> до всех остальных вершин графа описанным далее образом.

В начале работы алгоритма расстояние до вершины-источника <math>d(u)=0</math>, до остальных вершин <math>d(v) = \infty, \forall v \neq u </math>. Также в начале работы алгоритма инициализируется множество <math>F = \{u\}</math>.

Далее на каждом шаге алгоритма строится множество вершин <math>P = {w} </math>, таких, что для <math>\forall v \in F \exists (v, w) \in E | d(w) = \infty </math>, при этом обновляются расстояния <math>d(w)=d(v)+1</math> для <math>\forall w \in P </math>. Затем производится переход на следующий шаг до тех пор, пока <math>P \neq \emptyset</math>; при этом в начале каждого шага множество F заменяется на P.

=== Вычислительное ядро алгоритма ===

Вычислительным ядром алгоритма является обход вершин, смежных с выбранной вершиной <math>v</math>, с последующим добавлением еще не посещенных вершин в множество <math>P</math>. Данная операция выполняется на каждом шаге для каждой вершины <math>v \in F</math>.

=== Макроструктура алгоритма ===

Алгоритм последовательно уточняет значения функции <math>d(v)</math>.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>d(v)=\infty</math>, кроме вершины-источника, для которой <math>d(u)=0</math> .

2. Помещение вершины источника <math>v</math> в множество "передовых" вершин <math>F</math>.

3. Обход вершин множества <math>F</math>.

а) Инициализация множества <math>P=\emptyset</math>.

б) Для каждой вершины <math>v \in F</math> обход всех вершин <math>w | \exists (v, w)</math> (смежных с ней), c помещением в множество <math>P</math> таких вершин <math>w | d(w)=\infty</math>.

в) Замена множества <math>F</math> на <math>P</math> и переход на шаг 3 в случае, если множество <math>F \neq \emptyset</math>.

=== Схема реализации последовательного алгоритма ===

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

<source lang="C++">

// init distances
for(int i = 0; i < vertices_count; i++)
_result[i] = MAX_INT;

// init queue and first vertex
std::queue<int> vertex_queue;
vertex_queue.push(_source_vertex);
_result[_source_vertex] = 1;

// do bfs
while(vertex_queue.size() > 0)
{
int cur_vertex = vertex_queue.front();
vertex_queue.pop();

long long first = vertices_to_edges_ptrs[cur_vertex];
long long last = vertices_to_edges_ptrs[cur_vertex + 1];
for(long long i = first; i < last; i++)
{
int dst_id = dst_ids[i];
if(_result[dst_id] == MAX_INT)
{
_result[dst_id] = _result[src_id] + 1;
vertex_queue.push(dst_id);
}
}
}

</source>

=== Последовательная сложность алгоритма ===

Алгоритм имеет последовательную сложность <math>O(|V| + |E|)</math>, где <math>|V|</math> и <math>|E|</math> - число вершин и ребер графа соответственно: алгоритм инициализирует начальный массив расстояний - <math>O(|V|)</math> операций, а затем обходит каждую вершину один единственный раз - <math>O(|E|)</math> операций. Данная оценка верна в случае, если формат хранения графа позволяет обходить вершины, смежные к выбранной (к примеру форматы списка смежности, сжатого списка смежности). При использовании других форматов оценка сложности может быть большей.

=== Информационный граф ===

Информационный граф классического алгоритма поиска в ширину приведен на рисунке 1.

[[Файл:Classical_BFS_ig.png|thumb|center|500px|Рисунок 1. Информационный граф алгоритма BFS.]]

На рисунке 1 используются следующие обозначения:

[1] - добавление вершины-источника <math>u</math> к множеству <math>F</math>.

[2] - извлечение добавленной вершины <math>v</math> из множества <math>F</math>.

[3] - проверка расстояний до вершин, смежных с вершиной <math>v</math>.

[4] - добавление еще не посещенных вершин в множество <math>P</math>.

[5] - замена множества <math>F</math> на <math>P</math> и проверка его пустоты. В случае непустого множества - переход на следующую итерацию, иначе завершение работы алгоритма.

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

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

[[Файл:BFS_ig_parallel_queues.png|thumb|center|500px|Рисунок 2. Информационный граф алгоритма BFS (независимые структуры данных).]]

Обозначения для рисунка 2:

[1] - добавление вершины-источника в множество <math>F</math>.

[2] - разделение данных множества <math>F</math> между процессами

[3] - помещение в множества <math>F_i</math> соответствующих данных из <math>F</math> каждым процессом с номером i.

[4] - извлечение очередной вершины из множеств <math>F_i</math>, обход её соседей и добавление их в множество <math>P_i</math> в случае, если они еще не посещены

[5] - попарное слияние множеств <math>P_i</math> для различных процессов, итоговое преобразование их в множество <math>F</math>.

[6] - проверка условия выхода из цикла

Кроме того, в случае, если реализация структур данных, моделирующих множества <math>F</math> и <math>P</math>, невозможна, может использоваться квадратичный по сложности алгоритм, схожий с алгоритм Беллмана-Форда. Основная идея заключается в том, что на каждом шаге производится обход всех ребер графа с обновлением текущего массива дистанций. Информационный граф данной модификации алгоритма приведен на рисунке 3.

[[Файл:quadratic_BFS_ig.png|thumb|center|500px|Рисунок 3. Информационный граф алгоритма BFS (квадратичный подход к распараллеливанию).]]

Обозначения для рисунка 3:

[1] - инициализация расстояний до вершины-источника

[2] - инициализация расстояний до остальных вершин графа

[3] - загрузка информации об очередном ребре и обновление дистанций до соответствующих вершин.

[4] - проверка условия выхода из цикла

=== Ресурс параллелизма алгоритма ===

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

Произведем оценку ширины ярусно-параллельной формы алгоритма через максимальное число вершин p в слое среди всех шагов алгоритма. Тогда число параллельных операций на данном слое будет равно сумме числа смежных вершин для каждой вершины слоя: <math>\sum_{n=1}^{p} degree(v_i)</math>, при этом для каждого слоя данное значение будет различным. Высота ярусно-параллельной формы будет равна числу шагов в алгоритме и может быть оценена только сверху (не более <math>|V|</math>).

При квадратичном подходе к параллельной реализации алгоритма на каждом шаге выполняется <math>O(|E|)</math> операций, которые могут быть выполнены параллельно; таким образом, ширина ЯПФ данной модификации алгоритма равна <math>O(|E|)</math>. Число шагов алгоритма, как и в классическом случае, зависит от структуры графа и может быть оценено сверху как <math>O(|V|)</math>.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': граф <math>G(V, E)</math>, <math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math>, вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа расстояние <math>d(v)</math>, определенное как число ребер, лежащих на кратчайшем пути от вершины <math>u</math> к <math>v</math>.
# для каждой вершины <math>v</math> исходного графа значение достижимости (достижима или нет) от вершины-источника <math>u</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* Распределённый алгоритм поиска вширь является вычислительным ядром бенчмарка [http://www.graph500.org Graph500].
** MPI: {{Buttonlinkimp|12}}
* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/breadth_first_search.html breadth_first_search]</code>, <code>[http://www.boost.org/libs/graph/doc/breadth_first_visit.html breadth_first_visit]</code>).
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/breadth_first_search.html breadth_first_search]</code>).{{Buttonlinkimp|11}}
* Java: [http://webgraph.di.unimi.it WebGraph] (класс <code>[http://webgraph.di.unimi.it/docs/it/unimi/dsi/webgraph/algo/ParallelBreadthFirstVisit.html ParallelBreadthFirstVisit]</code>), многопоточная реализация.
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.traversal.breadth_first_search.bfs_edges.html bfs_edges]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.BFS networkit.graph.BFS]</code>).
* RCC for CPU {{Buttonlinkimp|9}}
* RCC for GPU {{Buttonlinkimp|26}}
* Gap {{Buttonlinkimp|36}}
* Litra {{Buttonlinkimp|39}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Breadth-first search (BFS)]]

Шаблон:Buttonlinkimp

2018-06-19T10:59:41Z

Apaokin: Новая страница: «{{Buttonlink|http://top53.parallel.ru/algo_results/implementation/{{{1}}}}}»

{{Buttonlink|http://top53.parallel.ru/algo_results/implementation/{{{1}}}}}

Шаблон:Buttonlink

2018-06-18T16:45:31Z

Apaokin:

[{{{1}}} <span style="font-size:10px;" class="mw-ui-button mw-ui-progressive">Get Perf.Data</span>]

MediaWiki:Common.js

2018-06-15T14:39:38Z

Apaokin:

/* Размещённый здесь код JavaScript будет загружаться пользователям при обращении к каждой странице */

(function () {

$('head').append("<script type='text/javascript' src='http://www.x3dom.org/download/x3dom.js'> </script> <link rel='stylesheet' type='text/css' href='http://www.x3dom.org/download/x3dom.css'></link>");

// $('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><box></box></shape></scene></x3d>");

$('#webgl-example').html("<x3d width='600px' height='400px'><scene><shape><appearance><material diffuseColor='1 0 0'></material></appearance><box></box></shape><transform translation='-3 0 0'><shape><appearance><material diffuseColor='0 1 0'></material></appearance><cone></cone></shape></transform><transform translation='3 0 0'><shape><appearance><material diffuseColor='0 0 1'></material></appearance><sphere></sphere></shape></transform></scene></x3d>");

}());

Алгоритм Δ-шагания

2018-06-15T14:34:25Z

Apaokin:

{{level-a}}
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм дельта-шагания'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> (англ. Δ-Stepping) предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм изначально проектировался с целью эффективной параллелизации.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
Псевдокод последовательного алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''W'';
вершина-источник ''u'';
параметр ''Δ'' > 0.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''procedure''' DeltaStepping(''V'', ''E'', ''W'', ''u'', ''Δ''):
''LightEdges'' := { e ∈ E | W(e) ≤ Δ }
''HeavyEdges'' := { e ∈ E | W(e) > Δ }
'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
Relax(''u'', 0)
'''while''' any({ ''Buckets''(i) ≠ ∅ }):
''Bucket'' := first({ ''Buckets''(i) ≠ ∅ })
''Deleted'' := ∅
'''while''' ''Bucket'' ≠ ∅:
''Requests'' := FindRequests(''Bucket'', ''LightEdges'')
''Deleted'' := ''Deleted'' ∪ ''Bucket''
''Bucket'' := ∅
RelaxAll(''Requests'')
RelaxAll(FindRequests(''Deleted'', ''HeavyEdges''))

'''procedure''' Relax(''v'', ''x''):
'''if''' ''x'' < ''d''(''v''):
''OldBucket'' := B(⌊''d''(''v'') / ''Δ''⌋)
''NewBucket'' := B(⌊''x'' / ''Δ''⌋)
''OldBucket'' := ''OldBucket'' \ {''v''}
''NewBucket'' := ''NewBucket'' ∪ {''v''}
''d''(''v'') := ''x''

'''procedure''' RelaxAll(''R''):
'''for each''' (''v'', ''x'') ∈ ''R'' '''do''' Relax(''v'', ''x'')

'''function''' FindRequests(''V<nowiki>'</nowiki>'', ''E<nowiki>'</nowiki>''):
'''return''' { (''w'', ''d''(''w'') + ''W''(''v'', ''w'')) | ''v'' ∈ ''V<nowiki>'</nowiki>'' and (''v'', ''w'') ∈ ''E<nowiki>'</nowiki>''}

=== Последовательная сложность алгоритма ===

Средняя последовательная сложность алгоритма на графах со случайными весами <math>O(n + m + dL)</math>, где <math>L</math> – максимальный суммарный вес кратчайшего пути, <math>d</math> – максимальная длина кратчайшего пути.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Средняя время работы параллельного алгоритма на графах со случайными весами на <math>O(n)</math> процессорах составляет <math>O((dL + \ln n) \ln n)</math> со средней работой <math>O(n + m + dL \ln n)</math>

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма===

Предельные случаи алгоритма Δ-шагания:
* при <math>\Delta \to 0</math>: [[алгоритм Дейкстры]];
* при <math>\Delta \to \infty</math>: [[алгоритм Беллмана-Форда]].

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#delta-stepping-algorithm delta_stepping_shortest_paths]</code>). {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/25}}
* Gap: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/38}}
== Литература ==

<references />

[[Категория:Начатые статьи]]

[[en:Δ-stepping algorithm]]

Алгоритм Беллмана-Форда

2018-06-15T14:32:18Z

Apaokin:

{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).
* OpenMP Stinger {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/10}}
* Nvidia nvGraph {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/19}}
* Graph500 MPI {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/24}}
* Ligra {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/41}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-15T14:31:25Z

Apaokin:

{{level-p}}
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}}
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}}
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}}
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Алгоритм Дейкстры

2018-06-15T14:30:00Z

Apaokin:

{{level-a}}
Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Δ-шагания

2018-06-15T10:41:41Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}} </indicator>
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм дельта-шагания'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> (англ. Δ-Stepping) предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм изначально проектировался с целью эффективной параллелизации.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
Псевдокод последовательного алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''W'';
вершина-источник ''u'';
параметр ''Δ'' > 0.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''procedure''' DeltaStepping(''V'', ''E'', ''W'', ''u'', ''Δ''):
''LightEdges'' := { e ∈ E | W(e) ≤ Δ }
''HeavyEdges'' := { e ∈ E | W(e) > Δ }
'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
Relax(''u'', 0)
'''while''' any({ ''Buckets''(i) ≠ ∅ }):
''Bucket'' := first({ ''Buckets''(i) ≠ ∅ })
''Deleted'' := ∅
'''while''' ''Bucket'' ≠ ∅:
''Requests'' := FindRequests(''Bucket'', ''LightEdges'')
''Deleted'' := ''Deleted'' ∪ ''Bucket''
''Bucket'' := ∅
RelaxAll(''Requests'')
RelaxAll(FindRequests(''Deleted'', ''HeavyEdges''))

'''procedure''' Relax(''v'', ''x''):
'''if''' ''x'' < ''d''(''v''):
''OldBucket'' := B(⌊''d''(''v'') / ''Δ''⌋)
''NewBucket'' := B(⌊''x'' / ''Δ''⌋)
''OldBucket'' := ''OldBucket'' \ {''v''}
''NewBucket'' := ''NewBucket'' ∪ {''v''}
''d''(''v'') := ''x''

'''procedure''' RelaxAll(''R''):
'''for each''' (''v'', ''x'') ∈ ''R'' '''do''' Relax(''v'', ''x'')

'''function''' FindRequests(''V<nowiki>'</nowiki>'', ''E<nowiki>'</nowiki>''):
'''return''' { (''w'', ''d''(''w'') + ''W''(''v'', ''w'')) | ''v'' ∈ ''V<nowiki>'</nowiki>'' and (''v'', ''w'') ∈ ''E<nowiki>'</nowiki>''}

=== Последовательная сложность алгоритма ===

Средняя последовательная сложность алгоритма на графах со случайными весами <math>O(n + m + dL)</math>, где <math>L</math> – максимальный суммарный вес кратчайшего пути, <math>d</math> – максимальная длина кратчайшего пути.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Средняя время работы параллельного алгоритма на графах со случайными весами на <math>O(n)</math> процессорах составляет <math>O((dL + \ln n) \ln n)</math> со средней работой <math>O(n + m + dL \ln n)</math>

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма===

Предельные случаи алгоритма Δ-шагания:
* при <math>\Delta \to 0</math>: [[алгоритм Дейкстры]];
* при <math>\Delta \to \infty</math>: [[алгоритм Беллмана-Форда]].

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#delta-stepping-algorithm delta_stepping_shortest_paths]</code>). {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/25}}
* Gap: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/38}}
== Литература ==

<references />

[[Категория:Начатые статьи]]

[[en:Δ-stepping algorithm]]

Алгоритм Дейкстры

2018-06-15T09:52:02Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Δ-шагания

2018-06-15T09:49:55Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}} </indicator>
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм дельта-шагания'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> (англ. Δ-Stepping) предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм изначально проектировался с целью эффективной параллелизации.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
Псевдокод последовательного алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''W'';
вершина-источник ''u'';
параметр ''Δ'' > 0.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''procedure''' DeltaStepping(''V'', ''E'', ''W'', ''u'', ''Δ''):
''LightEdges'' := { e ∈ E | W(e) ≤ Δ }
''HeavyEdges'' := { e ∈ E | W(e) > Δ }
'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
Relax(''u'', 0)
'''while''' any({ ''Buckets''(i) ≠ ∅ }):
''Bucket'' := first({ ''Buckets''(i) ≠ ∅ })
''Deleted'' := ∅
'''while''' ''Bucket'' ≠ ∅:
''Requests'' := FindRequests(''Bucket'', ''LightEdges'')
''Deleted'' := ''Deleted'' ∪ ''Bucket''
''Bucket'' := ∅
RelaxAll(''Requests'')
RelaxAll(FindRequests(''Deleted'', ''HeavyEdges''))

'''procedure''' Relax(''v'', ''x''):
'''if''' ''x'' < ''d''(''v''):
''OldBucket'' := B(⌊''d''(''v'') / ''Δ''⌋)
''NewBucket'' := B(⌊''x'' / ''Δ''⌋)
''OldBucket'' := ''OldBucket'' \ {''v''}
''NewBucket'' := ''NewBucket'' ∪ {''v''}
''d''(''v'') := ''x''

'''procedure''' RelaxAll(''R''):
'''for each''' (''v'', ''x'') ∈ ''R'' '''do''' Relax(''v'', ''x'')

'''function''' FindRequests(''V<nowiki>'</nowiki>'', ''E<nowiki>'</nowiki>''):
'''return''' { (''w'', ''d''(''w'') + ''W''(''v'', ''w'')) | ''v'' ∈ ''V<nowiki>'</nowiki>'' and (''v'', ''w'') ∈ ''E<nowiki>'</nowiki>''}

=== Последовательная сложность алгоритма ===

Средняя последовательная сложность алгоритма на графах со случайными весами <math>O(n + m + dL)</math>, где <math>L</math> – максимальный суммарный вес кратчайшего пути, <math>d</math> – максимальная длина кратчайшего пути.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Средняя время работы параллельного алгоритма на графах со случайными весами на <math>O(n)</math> процессорах составляет <math>O((dL + \ln n) \ln n)</math> со средней работой <math>O(n + m + dL \ln n)</math>

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма===

Предельные случаи алгоритма Δ-шагания:
* при <math>\Delta \to 0</math>: [[алгоритм Дейкстры]];
* при <math>\Delta \to \infty</math>: [[алгоритм Беллмана-Форда]].

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#delta-stepping-algorithm delta_stepping_shortest_paths]</code>).
{{Buttonlink|http://top53.parallel.ru/algo_results/implementation/25}}
* Gap: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/38}}
== Литература ==

<references />

[[Категория:Начатые статьи]]

[[en:Δ-stepping algorithm]]

Классификация алгоритмов

2018-06-15T09:06:03Z

Apaokin:

__TOC__
= Задачи алгебры =
==Матричные и векторные операции==
===Векторные операции===
# {{level|Суммирование сдваиванием}}
## {{level|Нахождение суммы элементов массива сдваиванием}}
## {{level|Нахождение частных сумм элементов массива сдваиванием}}
# {{level|Равномерная норма вектора, вещественная версия, последовательно-параллельный вариант}}
# {{level|Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант}}
# {{level|Последовательно-параллельный метод суммирования}}
=== Умножения матриц на вектор ===
==== Умножения неособенных матриц на вектор ====
# {{level|Умножение плотной неособенной матрицы на вектор (последовательный вещественный вариант)}}
==== Умножения матриц специального вида на вектор ====
# {{level|Преобразование Фурье}}
## {{level|Быстрое преобразование Фурье для составной размерности}}
### {{level|Быстрое преобразование Фурье для степеней двойки}}
#### {{level|Простой алгоритм Кули-Тьюки быстрого преобразования Фурье для степеней двойки}}
#### {{level|Быстрое преобразование Фурье для чётных степеней двойки}}
### {{level|Быстрое преобразование Фурье для составной размерности с небольшими простыми делителями (2,3,5,7)}}
## {{level|Быстрое преобразование Фурье для простой размерности}}
===Матричные операции===
# {{level|Умножение плотных матриц}}
## {{level|Перемножение плотных неособенных матриц (последовательный вещественный вариант)}}
## {{level|Метод Штрассена}}
==Разложения матриц==
{{level|Задача разложения матриц}}
# {{level|Треугольные разложения}}
## {{level|Метод Гаусса (нахождение LU-разложения)}}
### {{level|LU-разложение методом Гаусса без перестановок}}
#### {{level|LU-разложение методом Гаусса}}
#### {{level|Компактная схема метода Гаусса и её модификации}}
##### {{level|Компактная схема метода Гаусса для плотной матрицы}}
##### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы и её модификации}}
###### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы, последовательный вариант}}
###### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}
###### {{level|Последовательно-параллельный алгоритм для LU-разложения трёхдиагональной матрицы}}
### {{level|LU-разложение методом Гаусса с перестановками}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по столбцу}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по строке}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по главной диагонали}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по всей матрице}}
## {{level|Метод Холецкого (нахождение симметричного треугольного разложения)}}
### {{level|Разложение Холецкого (метод квадратного корня)}} базовый точечный вещественный вариант для плотной симметричной положительно-определённой матрицы
# {{level|Известные треугольные разложения для матриц специального вида}}
# {{level|Унитарно-треугольные разложения}}
## {{level|QR-разложения плотных неособенных матриц}}
### {{level|Метод Гивенса (вращений) QR-разложения матрицы}}
#### {{level|Метод Гивенса (вращений) QR-разложения квадратной матрицы (вещественный точечный вариант)}}
### {{level|Метод Хаусхолдера (отражений) QR-разложения матрицы}}
#### {{level|Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант}}
### {{level|Метод ортогонализации}}
#### {{level|Классический метод ортогонализации}}
#### {{level|Метод ортогонализации с переортогонализацией}}
### {{level|Метод треугольного разложения матрицы Грама}}
## {{level|Методы QR-разложения плотных хессенберговых матриц}}
### {{level|Метод Гивенса (вращений) QR-разложения хессенберговой матрицы (вещественный вариант)}}
### {{level|Метод Хаусхолдера (отражений) QR-разложения хессенберговой матрицы (вещественный вариант)}}
# {{level|Разложения, содержащие матрицу, подобную исходной}}
## {{level|Разложения, содержащие хессенбергову матрицу, унитарно подобную исходной}}
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|Классический точечный метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
### {{level|Метод Гивенса (вращений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|Классический точечный метод Гивенса (вращений) приведения матрицы к хессенберговой (почти треугольной) форме}}
## {{level|Разложения, содержащие трёхдиагональную матрицу, унитарно подобную исходной}}
### {{level|Метод Хаусхолдера (отражений) приведения к трёхдиагональному виду}}
#### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}
#### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}
### {{level|Метод Гивенса (вращений) приведения матрицы к трёхдиагональной форме}}
## {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
# {{level|Разложения с использованием унитарных преобразований, не содержащие матриц, подобной исходной}}
## {{level|Разложения на две унитарные и одну двухдиагональную матрицы}}
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме}}
### {{level|Метод Гивенса (вращений) приведения матрицы к двухдиагональной форме}}
## {{level|Разложения на две унитарные и одну диагональную матрицы}}
### {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
#### {{level|Методы нахождения сингулярных чисел двухдиагональных матриц}}
##### {{level|Алгоритм dqds нахождения сингулярных чисел двухдиагональной матрицы}}
###### {{level|Итерация алгоритма dqds}}

==Решение систем линейных уравнений==
# {{level|Прямые методы решения СЛАУ}}
## {{level|Linpack benchmark}}
## {{level|Методы решения СЛАУ с матрицами специального вида}}
### {{level|Методы решения СЛАУ с треугольными матрицами}}
#### {{level|Прямая подстановка (вещественный вариант)}}
#### {{level|Обратная подстановка (вещественный вариант)}}
#### {{level|Методы решения СЛАУ с двудиагональными матрицами}}
##### {{level|Прямая и обратная подстановка в СЛАУ с двухдиагональной матрицей}}
##### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}
##### {{level|Последовательно-параллельный вариант обратной подстановки}}
### {{level|Методы решения СЛАУ с трёхдиагональными матрицами}}
#### {{level|Методы, основанные на стандартном LU-разложении матрицы}}
##### {{level|Прогонка}}
###### {{level|Прогонка, точечный вариант}}
###### {{level|Классическая монотонная прогонка, повторный вариант}}
##### {{level|Метод сдваивания Стоуна}}
###### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}
###### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}
##### {{level|Последовательно-параллельный вариант решения трёхдиагональной СЛАУ с LU-разложением и обратными подстановками}}
#### Другие методы
##### {{level|Метод редукции}}
###### {{level|Полный метод редукции}}
###### {{level|Повторный метод редукции для новой правой части}}
##### {{level|Встречная прогонка}}
###### {{level|Встречная прогонка, точечный вариант}}
###### {{level|Повторная встречная прогонка, точечный вариант}}
##### {{level|Метод циклической редукции}}
###### {{level|Полный метод циклической редукции}}
###### {{level|Повторный метод циклической редукции для новой правой части}}
##### {{level|Метод окаймления}}
### Методы решения СЛАУ с блочно-треугольными матрицами
#### {{level|Блочная прямая подстановка (вещественный вариант)|Блочная прямая подстановка}}
#### {{level|Блочная обратная подстановка (вещественный вариант)|Блочная обратная подстановка}}
#### Методы решения СЛАУ с блочно-двухдиагональными матрицами
##### {{level|Прямая и обратная подстановка в СЛАУ с блочно-двухдиагональной матрицей}}
##### {{level|Метод сдваивания Стоуна для решения блочно-двухдиагональных СЛАУ}}
##### {{level|Блочный последовательно-параллельный вариант обратной подстановки для решения блочно-двухдиагональных СЛАУ}}
### {{level|Методы решения СЛАУ с блочно-трёхдиагональными матрицами}}
#### Методы, основанные на стандартном LU-разложении матрицы
##### {{level|Блочная прогонка}}
##### {{level|Блочный последовательно-параллельный вариант решения с LU-разложением и обратными подстановками}}
#### Другие методы
##### {{level|Встречная прогонка, блочный вариант}}
##### {{level|Блочный метод циклической редукции}}
##### {{level|Блочный метод окаймления}}
## {{level|Решения СЛАУ с матрицами специального вида, имеющими известные обратные матрицы}}
# Итерационные методы решения СЛАУ
## {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
## {{level|Стабилизированный метод бисопряженных градиентов (BiCGStab)}}
## {{level|Алгоритм_Качмажа}}

==Решения спектральных задач==
# {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
## {{level|QR-алгоритм}}
### {{level|QR-алгоритм, используемый в SCALAPACK}}
#### {{level|Классический точечный метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|QR-алгоритм для хессенберговой матрицы, используемый в SCALAPACK}}
### {{level|QR-алгоритм для симметричных матриц, используемый в SCALAPACK}}
#### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}
#### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}
### {{level|QR-алгоритм для комплексных эрмитовых матриц, используемый в SCALAPACK}}
#### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}
#### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}
## {{level|Метод Якоби (вращений) для решения спектральной задачи у симметричных матриц}}
### {{level|Классический метод Якоби (вращений) для симметричных матриц с выбором по всей матрице}}
### {{level|Метод Якоби (вращений) для симметричных матриц с циклическим исключением}}
### {{level|Метод Якоби (вращений) для симметричных матриц с циклическим исключением и барьерами}}
## {{level|Метод Ланцоша}}
### {{level|Алгоритм Ланцоша для точной арифметики (без переортогонализации)}}
# {{level|Частичная спектральная задача}}
## {{level|Метод бисекций}}
# {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
## {{level|Метод Якоби (вращений) для нахождения сингулярных значений неособенных матриц}}
### {{level|Метод Якоби (вращений) для нахождения сингулярных значений с циклическим перебором}}
### {{level|Метод Якоби для нахождения сингулярных значений со специальным подбором вращений}}
## {{level|QR-алгоритм в приложении к сингулярному разложению}}
==Алгебра многочленов==
# {{level|Схема Горнера, вещественная версия, последовательный вариант}}

= Алгоритмы на списках и массивах =
==Алгоритмы поиска==
# {{level|Линейный поиск - находит элемент в любом списке|Линейный поиск}}, <math>O(n)</math>
# {{level|Двоичный поиск - находит элемент в отсортированном списке|Двоичный поиск}}, <math>O(\log(n))</math>
==Алгоритмы сортировки==
# {{level|Сортировка с помощью двоичного дерева}}
# {{level|Сортировка пузырьком}}
# {{level|Сортировка слиянием (последовательный и параллельный варианты)}}
==Алгоритмы на графах==
# Обход графа
## {{level|Поиск в ширину (BFS)}}
## {{level|Поиск в глубину (DFS)}}
# {{level|Поиск кратчайшего пути от одной вершины (SSSP)}}
## {{level|Поиск в ширину (BFS)}} (для невзвешенных графов)
## {{level|Алгоритм Дейкстры}}
## {{level|Алгоритм Беллмана-Форда}}
## {{level|Алгоритм Δ-шагания}}
# {{level|Поиск кратчайшего пути для всех пар вершин (APSP)}}
## {{level|Алгоритм Джонсона}}
## {{level|Алгоритм Флойда-Уоршелла}}
# {{level|Поиск транзитивного замыкания орграфа}}
## {{level|Алгоритм Пурдома}}
# {{level|Определение диаметра графа}}
# {{level|Построение минимального остовного дерева (MST)}}
## {{level|Алгоритм Борувки}}
## {{level|Алгоритм Крускала}}
## {{level|Алгоритм Прима}}
## {{level|Алгоритм GHS}}
# {{level|Поиск изоморфных подграфов}}
## {{level|Алгоритм Ульмана}}
## {{level|Алгоритм VF2}}
# {{level|Связность в графах}}
## {{level|Алгоритм Шилоаха-Вишкина поиска компонент связности}}
## {{level|Система непересекающихся множеств}}
## {{level|Алгоритм Тарьяна поиска компонент сильной связности}}
## {{level|Алгоритм DCSC поиска компонент сильной связности}}
## {{level|Алгоритм Тарьяна поиска компонент двусвязности}}
## {{level|Алгоритм Тарьяна-Вишкина поиска компонент двусвязности}}
## {{level|Алгоритм Тарьяна поиска «мостов» в графе}}
## {{level|Определение вершинной связности графа}}
## {{level|Алгоритм Габова определения рёберной связности графа}}
# {{level|Поиск максимального потока в транспортной сети}}
## {{level|Алгоритм Форда-Фалкерсона}}
## {{level|Алгоритм проталкивания предпотока}}
# {{level|Поиск потока минимальной стоимости в транспортной сети}}
# {{level|Задача о назначениях}}
## {{level|Венгерский алгоритм}}
## {{level|Алгоритм аукциона}}
## {{level|Алгоритм Гопкрофта-Карпа}}
# {{level|Вычисление betweenness centrality|Вычисление центральности вершин}}
=Вычислительная геометрия=
# {{level|Поиск диаметра множества точек}}
# {{level|Построение выпуклой оболочки набора точек}}
# {{level|Триангуляция Делоне}}
# {{level|Диаграмма Вороного}}
# {{level|Принадлежность точки многоугольнику}}
# {{level|Пересечения выпуклых многоугольников}}
# {{level|Пересечение звёздных многоугольников}}
==Компьютерная графика==
# {{level|Алгоритмы построения отрезка - алгоритмы для аппроксимации отрезка на дискретной графической поверхности}}
# {{level|Алгоритм определения видимых частей трёхмерной сцены}}
# {{level|Трассировка лучей - рендеринг реалистичных изображений}}
# {{level|Глобальное освещение - рассматривает прямое освещение и отражение от других объектов}}

=Исследование и моделирование компьютеров=
==Тесты производительности компьютеров==
# {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
# {{level|Linpack benchmark}}
==Алгоритмы моделирования квантовых систем==
# {{level|Алгоритмы моделирования квантовых вычислений}}
## {{level|Однокубитное преобразование вектора-состояния}}
## {{level|Двухкубитное преобразование вектора-состояния}}
## {{level|Моделирование квантового преобразования Фурье}}
==Алгоритмы машинного обучения==
# {{level|Алгоритм k средних (k-means)}}
===Нейронные сети===
# {{level|Распознавание образов}}
## {{level|Распознавание текста}}
## {{level|Распознавание речи}}
## {{level|Распознавание лиц}}
===Алгоритмы теории игр===

= Прикладные задачи из разных областей =
==Алгоритмы оптимизации==
# {{level|Линейное программирование}}
# {{level|Симплекс-метод}}
# {{level|Метод ветвей и границ}}
# {{level|Генетические алгоритмы}}
# {{level|Муравьиные алгоритмы}}
# {{level|Комбинированные алгоритмы}}
# {{level|Стохастическое двойственное динамическое программирование (SDDP)}}
==Решение систем нелинейных уравнений==
# {{level|Метод Ньютона для систем нелинейных уравнений}}
==Численные методы интегрирования==
# {{level|Квадратурные формулы}}
# {{level|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)}}
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод прямоугольников|Метод прямоугольников]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод трапеций|Метод трапеций]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод парабол (метод Симпсона)|Метод парабол (метод Симпсона)]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод Гаусса|Метод Гаусса]]
==Алгоритмы решения уравнений математической физики==
# {{level|Уравнение Пуассона, решение дискретным преобразованием Фурье}}
=Криптографические алгоритмы=
# {{level|Метод встречи посередине}}
=Другие алгоритмы=

[[en:Algorithm classification]]

[[Категория:Алгоритмы|*]]

Алгоритм Дейкстры

2018-06-15T09:04:02Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).
* Gap {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/38}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Беллмана-Форда

2018-06-15T08:59:04Z

Apaokin:

<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}} </indicator>
{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).
* OpenMP Stinger {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/10}}
* Nvidia nvGraph {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/19}}
* Graph500 MPI {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/24}}
* Ligra {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/41}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Алгоритм Беллмана-Форда

2018-06-15T08:58:22Z

Apaokin:

<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}} </indicator>
{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).
* OpenMP Stinger {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/10}}
* Nvidia nvGraph {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/19}}
* Graph500 MPI {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/24}}
* Ligra {{http://top53.parallel.ru/algo_results/implementation/41}}
== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Алгоритм Дейкстры

2018-06-15T08:40:45Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]: {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Δ-шагания

2018-06-15T08:35:32Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}} </indicator>
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм дельта-шагания'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> (англ. Δ-Stepping) предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм изначально проектировался с целью эффективной параллелизации.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
Псевдокод последовательного алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''W'';
вершина-источник ''u'';
параметр ''Δ'' > 0.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''procedure''' DeltaStepping(''V'', ''E'', ''W'', ''u'', ''Δ''):
''LightEdges'' := { e ∈ E | W(e) ≤ Δ }
''HeavyEdges'' := { e ∈ E | W(e) > Δ }
'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
Relax(''u'', 0)
'''while''' any({ ''Buckets''(i) ≠ ∅ }):
''Bucket'' := first({ ''Buckets''(i) ≠ ∅ })
''Deleted'' := ∅
'''while''' ''Bucket'' ≠ ∅:
''Requests'' := FindRequests(''Bucket'', ''LightEdges'')
''Deleted'' := ''Deleted'' ∪ ''Bucket''
''Bucket'' := ∅
RelaxAll(''Requests'')
RelaxAll(FindRequests(''Deleted'', ''HeavyEdges''))

'''procedure''' Relax(''v'', ''x''):
'''if''' ''x'' < ''d''(''v''):
''OldBucket'' := B(⌊''d''(''v'') / ''Δ''⌋)
''NewBucket'' := B(⌊''x'' / ''Δ''⌋)
''OldBucket'' := ''OldBucket'' \ {''v''}
''NewBucket'' := ''NewBucket'' ∪ {''v''}
''d''(''v'') := ''x''

'''procedure''' RelaxAll(''R''):
'''for each''' (''v'', ''x'') ∈ ''R'' '''do''' Relax(''v'', ''x'')

'''function''' FindRequests(''V<nowiki>'</nowiki>'', ''E<nowiki>'</nowiki>''):
'''return''' { (''w'', ''d''(''w'') + ''W''(''v'', ''w'')) | ''v'' ∈ ''V<nowiki>'</nowiki>'' and (''v'', ''w'') ∈ ''E<nowiki>'</nowiki>''}

=== Последовательная сложность алгоритма ===

Средняя последовательная сложность алгоритма на графах со случайными весами <math>O(n + m + dL)</math>, где <math>L</math> – максимальный суммарный вес кратчайшего пути, <math>d</math> – максимальная длина кратчайшего пути.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Средняя время работы параллельного алгоритма на графах со случайными весами на <math>O(n)</math> процессорах составляет <math>O((dL + \ln n) \ln n)</math> со средней работой <math>O(n + m + dL \ln n)</math>

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма===

Предельные случаи алгоритма Δ-шагания:
* при <math>\Delta \to 0</math>: [[алгоритм Дейкстры]];
* при <math>\Delta \to \infty</math>: [[алгоритм Беллмана-Форда]].

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#delta-stepping-algorithm delta_stepping_shortest_paths]</code>).
{{Buttonlink|http://top53.parallel.ru/algo_results/implementation/25}}

== Литература ==

<references />

[[Категория:Начатые статьи]]

[[en:Δ-stepping algorithm]]

Алгоритм Беллмана-Форда

2018-06-15T08:31:08Z

Apaokin:

<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}} </indicator>
{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-15T08:26:40Z

Apaokin:

{{level-p}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/task/29}} </indicator>
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}}
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}}
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}}
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Шаблон:Buttonlink

2018-06-15T08:18:20Z

Apaokin:

[{{{1}}} <span style="font-size:10px;" class="mw-ui-button mw-ui-progressive">Get perf. data</span>]

MediaWiki:Common.js

2018-06-14T14:12:27Z

Apaokin:

MediaWiki:Common.js

2018-06-14T14:09:08Z

Apaokin:

MediaWiki:Common.js

2018-06-14T14:07:34Z

Apaokin:

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-14T13:22:52Z

Apaokin:

{{level-p}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}}
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}}
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>. {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}}
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Алгоритм Дейкстры

2018-06-14T13:18:30Z

Apaokin:

{{level-a}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]:
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref> {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Беллмана-Форда

2018-06-14T13:14:59Z

Apaokin:

{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}} </indicator>

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Алгоритм Беллмана-Форда

2018-06-14T13:14:26Z

Apaokin:

{{algorithm
| name = Алгоритм Беллмана-Форда
| serial_complexity = <math>O(|V||E|)</math>
| pf_height = <math>N/A, max O(|V|) </math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|^2)</math>
}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
http://top53.parallel.ru/algo_results/algorithm/6
== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Беллмана-Форда'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм Беллмана-Форда масштабируется хуже других алгоритмов решения указанной задачи (сложность <math>O(|V||E|)</math> против <math>O(|E| + |V|\ln(|V|))</math> у [[Алгоритм Дейкстры|алгоритма Дейкстры]]), однако его отличительной особенностью является применимость к графам с произвольными, в том числе отрицательными, весами.

=== Математическое описание алгоритма ===
Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Алгоритм Беллмана-Форда ищет функцию <math>d(v)</math> как единственное решение уравнения
:<math>
d(v) = \min \{ d(w) + f(e) \mid e = (w, v) \in E \}, \quad \forall v \ne u,
</math>
с начальным условием <math>d(u) = 0</math>.

=== Вычислительное ядро алгоритма ===
Основной операцией алгоритма является релаксация ребра: если <math>e = (w, v) \in E</math> и <math>d(v) > d(w) + f(e)</math>, то производится присваивание <math>d(v) \leftarrow d(w) + f(e)</math>.

=== Макроструктура алгоритма ===
Алгоритм последовательно уточняет значения функции <math>d(v)</math>.
* В самом начале производится присваивание <math>d(u) = 0</math>, <math>d(v) = \infty</math>, <math>\forall v \ne u</math>.
* Далее происходит <math>|V|-1</math> итерация, в ходе каждой из которых производится релаксация всех рёбер графа.

Структуру можно описать следующим образом:

1. Инициализация: всем вершинам присваивается предполагаемое расстояние <math>t(v)=\infty</math>, кроме вершины-источника, для которой <math>t(u)=0</math> .

2. Релаксация множества рёбер <math>E</math>

а) Для каждого ребра <math>e=(v,z) \in E</math> вычисляется новое предполагаемое расстояние <math>t^' (z)=t(v)+ w(e)</math>.

б) Если <math>t^' (z)< t(z)</math>, то происходит присваивание <math>t(z) := t' (z)</math> (релаксация ребра <math>e</math> ).

3. Алгоритм производит релаксацию всех рёбер графа до тех пор, пока на очередной итерации происходит релаксация хотя бы одного ребра.

Если на <math>|V|</math>-й итерации всё ещё производилась релаксацию рёбер, то в графе присутствует цикл отрицательной длины. Ребро <math>e=(v,z)</math>, лежащее на таком цикле, может быть найдено проверкой следующего условия (проверяется для всех рёбер за линейное время): <math>t(v)+w(e)<d(z)</math>

=== Схема реализации последовательного алгоритма ===
Последовательный алгоритм реализуется следующим псевдокодом:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
''d''(''u'') = 0

'''for''' ''i'' '''from''' 1 '''to''' |''V''| - 1:
'''for each''' ''e'' = (''w'', ''v'') ∈ ''E'':
'''if''' ''d''(''v'') > ''d''(''w'') + ''f''(''e''):
''d''(''v'') := ''d''(''w'') + ''f''(''e'')

=== Последовательная сложность алгоритма ===
Алгоритм выполняет <math>|V|-1</math> итерацию, на каждой из которых происходит релаксация <math>|E|</math> рёбер. Таким образом, общий объём работы составляет <math>O(|V||E|)</math> операций.

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

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

=== Информационный граф ===
На рисунке 1 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

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

Нижний уровень параллелизма на графе алгоритма расположен на уровнях [2] и [3], соответствующим операциям инициализации массива дистанций [2] и обновления массива c использованием данных массива ребер [3]. Операция [4] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

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

=== Ресурс параллелизма алгоритма ===

Алгоритм обладает значительным ресурсом параллелизма. Во-первых, поиск кратчайших путей от различных вершин может производиться независимо для каждой из вершин (параллельные вертикальные плоскости на рисунке 1). Во-вторых, поиск кратчайших путей от фиксированной вершины <math>u</math> также может выполняться параллельно: инициализация начальных путей [2] требует <math>|V|</math> параллельных операции, релаксация каждого ребра требует <math>O(|E|)</math> параллельных операции.

Таким образом, при наличии <math>O(|E|)</math> процессоров алгоритм завершит работу максимум за <math>|V|</math> шагов. В реальности, шагов обычно требуется меньше, а именно <math>O(r)</math> -(максимальная длина среди всех кратчайших путей от выбранной вершины-источника <math>u</math>).

Таким образом, ширина ярусно-параллельной формы алгоритма равна <math>O(|E|)</math>, высота ЯПФ - <math>O(r) | r < |V|</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Беллмана-Форда.

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>|V|</math> вершин <math>v_i</math> и <math>|E|</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(|V| + |E|)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(|V|)</math>.

=== Свойства алгоритма===

Алгоритм может распознавать наличие отрицательных циклов в графе. Ребро <math>e = (v, w)</math> лежит на таком цикле, если вычисленные алгоритмом кратчайшие расстояния <math>d(v)</math> удовлетворяют условию
:<math>
d(v) + f(e) < d(w),
</math>
где <math>f(e)</math> – вес ребра <math>e</math>. Условие может быть проверено для всех рёбер графа за время <math>O(|E|)</math>.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:bellman_ford_1.png|thumb|center|700px|Рисунок 2. Алгоритм Беллмана-Форда. Общий профиль обращений в память]]

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

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

[[file:bellman_ford_2.png|thumb|center|700px|Рисунок 3. Профиль обращений, фрагмент 1]]

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

[[file:bellman_ford_3.png|thumb|center|700px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 2]]

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

===== Количественная оценка локальности =====

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

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

[[file:bellman_ford_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====

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

==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Беллмана-Форда согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [1 : 28] с шагом 1;
* размер графа [2^20 : 2^27].

Проведем отдельные исследования сильной масштабируемости вширь реализации алгоритма Беллмана-Форда.

Производительность определена как TEPS (от англ. Traversed Edges Per Second), то есть число ребер графа, который алгоритм обрабатывает в секунду. С помощью данной метрики можно сравнивать производительность для различных размеров графа, оценивая, насколько понижается эффективность обработки графа при увеличении его размера.

[[file:Сильная_масштабируемость_вширь_алгоритма_Беллмана-Форда.png|thumb|center|700px|Рисунок 7. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 8. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 9. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 10. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 11. График кэш-промахов L2 в секунду при работе алгоритма Беллмана-Форда]]

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

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Это указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Bellman-Ford Inf Data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Беллмана-Форда]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на первом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Bellman-Ford Inf Pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Беллмана-Форда]]

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

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

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/bellman_ford_shortest.html bellman_ford_shortest]</code>).
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.bellman_ford.html bellman_ford]</code>).
* Java: [http://jgrapht.org JGraphT] (класс <code>[http://jgrapht.org/javadoc/org/jgrapht/alg/BellmanFordShortestPath.html BellmanFordShortestPath]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Bellman-Ford algorithm]]

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-14T13:12:06Z

Apaokin:

{{level-p}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}} </indicator>
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>.
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>.
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>.
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Алгоритм Дейкстры

2018-06-14T12:42:16Z

Apaokin:

{{level-a}}

Основные авторы описания: [[Участник:Daryin|А.Н.Дарьин]], [[Участник:VadimVV|Вад.В.Воеводин]] ([[#Описание локальности данных и вычислений|раздел 2.2]])

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Дейкстры'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref> предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа.
Алгоритм Дейкстры (с использованием фибоначчиевой кучи<ref name=FibHeap>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1987): 596–615. doi:10.1145/28869.28874.</ref>) выполняется за время <math>O(m + n \ln n)</math> и является асимптотически быстрейшим из известных последовательных алгоритмов для данного класса задач.

=== Математическое описание алгоритма ===

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Обозначим через <math>d(v)</math> кратчайшее расстояние от источника <math>u</math> до вершины <math>v</math>.

Пусть уже вычислены все расстояния, не превосходящие некоторого числа <math>r</math>, то есть расстояния до вершин из множества <math>V_r = \{ v \in V \mid d(v) \le r \}</math>. Пусть
:<math>
(v, w) \in \arg\min \{ d(v) + f(e) \mid v \in V, e = (v, w) \in E \}.
</math>
Тогда <math>d(w) = d(v) + f(e)</math>, и <math>v</math> лежит на кратчайшем пути от <math>u</math> к <math>w</math>.

Величины <math>d^+(w) = d(v) + f(e)</math>, где <math>v \in V_r</math>, <math>e = (v, w) \in E</math>, называются ''предполагаемыми расстояниями'' и являются оценкой сверху для настоящих расстояний: <math>d(w) \le d^+(w)</math>.

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

=== Вычислительное ядро алгоритма ===
Основные вычисления связаны с операциями над очередью с приоритетом:
* извлечение минимального элемента (<code>delete_min</code>);
* уменьшение приоритета элемента (<code>decrease_key</code>).

=== Макроструктура алгоритма ===
Псевдокод алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''f''(''e'');
вершина-источник ''u''.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

''Q'' := '''new''' priority queue
'''for each''' ''v'' ∈ ''V'':
'''if''' ''v'' = ''u'' '''then''' ''d''(''v'') := 0 '''else''' ''d''(''v'') := ∞
''Q''.insert(''v'', ''d''(''v''))

'''while''' ''Q'' ≠ ∅:
''v'' := ''Q''.delete_min()
'''for each''' ''e'' = (''v'', ''w'') ∈ ''E'':
'''if''' ''d''(''w'') > ''d''(''v'') + ''f''(''e''):
''d''(''w'') := ''d''(''v'') + ''f''(''e'')
''Q''.decrease_key(''w'', ''d''(''w''))

=== Схема реализации последовательного алгоритма ===
Конкретная реализация алгоритма Дейкстры определяется выбором используемого алгоритма очереди с приоритетом. В простейшем случае это может быть массив или список, поиск минимума в котором требует просмотра всех вершин. Более эффективным является использование кучи; наилучшую известную оценку сложности имеет вариант с использованием фибоначчиевой кучи<ref name=FibHeap />.

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

=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма равна <math>O(C_1 m + C_2n)</math>, где
* <math>C_1</math> – количество операций уменьшения расстояния до вершины;
* <math>C_2</math> – количество операций вычисления минимума.

Оригинальный алгоритм Дейкстры использовал в качестве внутренней структуры данных списки, для которых <math>C_1 = O(1)</math>, <math>C_2 = O(n)</math>, так что общая сложность составляла <math>O(n^2)</math>.

При использовании фибоначчиевой кучи<ref name=FibHeap /> время вычисления минимума сокращается до <math>C_2 = O(\ln n)</math>, так что общая сложность равна <math>O(m + n \ln n)</math>, что является асимптотически наилучшим известным результатом для данного класса задач.

=== Информационный граф ===
Приводится граф алгоритма для базовой реализации алгоритма Дейкстры на списках или массивах.
[[file:Deikstra.png|thumb|center|600px|Рисунок 1. Граф алгоритма без отображения входных и выходных данных. n=3. Желтым цветом обозначены операции сравнения, зеленым - операции изменения меток вершин, синим - пометка вершины.]]

=== Ресурс параллелизма алгоритма ===

Алгоритм Дейкстры допускает эффективную параллелизацию<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref>, среднее время работы <math>O(n^{1/3}\ln n)</math> с объёмом вычислений <math>O(n \ln n + m)</math>.

[[Алгоритм Δ-шагания]] может рассматриваться как параллельная версия алгоритма Дейкстры.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====

[[file:dijkstra_1.png|thumb|center|700px|Рисунок 1. Реализация алгоритма Дейкстры. Общий профиль обращений в память]]

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

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

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

[[file:dijkstra_2.png|thumb|center|700px|Рисунок 2. Профиль обращений, фрагмент 1]]

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

[[file:dijkstra_3.png|thumb|center|700px|Рисунок 3. Профили двух участков фрагмента 1 (выделены зеленым на рис. 2)]]

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

Заметим, что при этом число задействованных элементов здесь больше, чем во фрагменте 1, однако число обращений гораздо меньше.

[[file:dijkstra_4.png|thumb|center|500px|Рисунок 4. Профиль обращений, фрагмент 2]]

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

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

[[file:dijkstra_5.png|thumb|center|500px|Рисунок 5. Профиль обращений, фрагмент 3]]

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

===== Количественная оценка локальности =====

Основной фрагмент реализации, на основе которого были получены количественные оценки, приведен [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/benchmarks/dijkstra/dijkstra.h здесь] (функция Kernel). Условия запуска описаны [http://git.parallel.ru/shvets.pavel.srcc/locality/blob/master/README.md здесь].

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

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

[[file:dijkstra_daps.png|thumb|center|700px|Рисунок 6. Сравнение значений оценки daps]]

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

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

[[file:dijkstra_cvg.png|thumb|center|700px|Рисунок 7. Сравнение значений оценки cvg]]

=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов"<ref name="Lom">Воеводин Вл., Жуматий С., Соболев С., Антонов А., Брызгалов П., Никитенко Д., Стефанов К., Воеводин Вад. Практика суперкомпьютера «Ломоносов» // Открытые системы, 2012, N 7, С. 36-39.</ref> [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].
Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* число процессоров [4, 8 : 128] со значениями квадрата целого числа;
* размер графа [16000:64000] с шагом 16000.

На следующем рисунке приведен график [[Глоссарий#Производительность|производительности]] выбранной реализации алгоритма в зависимости от изменяемых параметров запуска.

[[file:Dijkstra perf.png|thumb|center|700px|Рисунок 8. Параллельная реализация алгоритма. Изменение производительности в зависимости от числа процессоров и размера области.]]

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

[https://code.google.com/p/prir-dijkstra-mpi/source/browse/trunk/project/dijkstra_mpi.c Исследованная параллельная реализация на языке C]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Дейкстры. Все результаты получены на суперкомпьютере "Ломоносов". Использовались процессоры Intel Xeon X5570 с пиковой производительностью в 94 Гфлопс, а также компилятор intel 13.1.0.
На рисунках показана эффективность реализации алгоритма Дейкстры на 32 процессах.

[[file:Dijkstra CPU User.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Дейкстры]]

На графике загрузки процессора видно, что почти все время работы программы уровень загрузки составляет около 50%. Это указывает на равномерную загруженность вычислениями процессоров, при использовании 8 процессов на вычислительный узел и без использования Hyper Threading.

[[file:Dijkstra Flops.png|thumb|center|700px|Рисунок 10. График операций с плавающей точкой в секунду при выполнении алгоритма Дейкстры]]

На Рисунке 10 показан график количества операций с плавающей точкой в секунду. На графике видна общая очень низкая производительность вычислений около 250 Kфлопс в пике и около 150 Кфлопс в среднем по всем узлам. Это указывает то, что в программе почти все вычисления производятся с целыми числами.
[[file:Dijkstra L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов первого уровня видно, что число промахов очень большое для нескольких ядер и находится на уровне 15 млн/сек (в пике до 60 млн/сек), что указывает на интенсивные вычисления в части процессов. В среднем по всем узлам значения значительно ниже (около 9 млн/сек). Это указывает на неравномерное распределение вычислений.
[[file:Dijkstra L3.png|thumb|center|700px|Рисунок 12. График кэш-промахов L3 в секунду при работе алгоритма Дейкстры]]

На графике кэш-промахов третьего уровня видно, что число промахов очень невелико и находится на уровне 1,2 млн/сек, однако в среднем по всем узлам значения около 0,5 млн/сек. Соотношение кэш промахов L1|L3 для процессов с высокой производительностью доходит до 60, однако в среднем около 30. Это указывает на очень хорошую локальность вычислений как у части процессов, так и для всех в среднем, и это является признаком высокой производительности.

[[file:Dijkstra Mem Load.png|thumb|center|700px|Рисунок 13. График количества чтений из оперативной памяти при работе алгоритма Дейкстры]]

На графике обращений в память видна достаточно типичная картина для таких приложений. Активность чтения достаточно низкая, что в совокупности с низкими значениями кэш-промахов L3 указывает на хорошую локальность. Хорошая локальность приложения также указывает на то, что значение около 1 млн/сек для задачи является результатом высокой производительности вычислений, хотя и присутствует неравномерность между процессами.
[[file:Dijkstra Mem Store.png|thumb|center|700px|Рисунок 14. График количества записей в оперативную память при работе алгоритма Дейкстры]]

На графике записей в память видна похожая картина неравномерности вычислений, при которой одновременно активно выполняют запись только несколько процессов. Это коррелирует с другими графиками выполнения. Стоит отметить достаточно низкое число обращений на запись в память. Это указывает на хорошую организацию вычислений и достаточно эффективную работу с памятью.
[[file:Dijkstra Inf DATA.png|thumb|center|700px|Рисунок 15. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая скорость передачи данных в байтах в секунду. Это говорит о том, что процессы между собой обмениваются интенсивно и вероятно достаточно малыми порциями данных, потому как производительность вычислений высока. Стоит отметить, что скорость передачи отличается между процессами, что указывает на дисбаланс вычислений.
[[file:Dijkstra Inf PCKTS.png|thumb|center|700px|Рисунок 16. График скорости передачи по сети Infiniband в пакетах/сек при работе алгоритма Дейкстры]]

На графике скорости передачи данных в пакетах в секунду наблюдается крайне высокая интенсивность передачи данных. Это говорит о том, что, вероятно, процессы обмениваются не очень существенными объемами данных, но очень интенсивно. Используются коллективные операции на каждом шаге с небольшими порциями данных, что объясняет такую картину. Также наблюдается меньший дизбаланс между процессами, чем наблюдаемый в графиках использования памяти, вычислений и передачи данных в байтах/сек. Это указывает на то, что процессы обмениваются по алгоритму одинаковым числом пакетов, однако получают разные объемы данных и ведут неравномерные вычисления.
[[file:Dijkstra Load ABG.png|thumb|center|700px|Рисунок 17. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Дейкстры]]
На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно и приблизительно равняется 8. Это свидетельствует о стабильной работе программы с загруженными вычислениями всеми узлами. Это указывает на очень рациональную и статичную загрузку аппаратных ресурсов процессами. И показывает достаточно хорошую эффективность выполняемой реализации.
В целом, по данным системного мониторинга работы программы можно сделать вывод о том, что программа работала достаточно эффективно, и стабильно. Использование памяти очень интенсивное, а использование коммуникационной среды крайне интенсивное, при этом объемы передаваемых данных не являются высокими. Это указывает на требовательность к латентности коммуникационной среды алгоритмической части программы.
Низкая эффективность связана, судя по всему, с достаточно высоким объемом пересылок на каждом процессе и с интенсивными обменами сообщениями.

=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++: [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функции <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths.html dijkstra_shortest_paths]</code>, <code>[http://www.boost.org/libs/graph/doc/dijkstra_shortest_paths_no_color_map.html dijkstra_shortest_paths_no_color_map]</code>), сложность <math>O(m + n \ln n)</math>.
* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library]:
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#eager-dijkstra-s-algorithm eager_dijkstra_shortest_paths]</code> – непосредственная реализация алгоритма Дейкстры;
** функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#crauser-et-al-s-algorithm crauser_et_al_shortest_paths]</code> – реализация алгоритма Дейкстры в виде алгоритма из статьи Краузера и др.<ref>Crauser, A, K Mehlhorn, U Meyer, and P Sanders. “A Parallelization of Dijkstra's Shortest Path Algorithm,” Proceedings of Mathematical Foundations of Computer Science / Lecture Notes in Computer Science, 1450:722–31, Berlin, Heidelberg: Springer, 1998. doi:10.1007/BFb0055823.</ref> {{Buttonlink|http://top53.parallel.ru/algo_results/implementation/14}}
* Python: [https://networkx.github.io NetworkX] (функция <code>[http://networkx.github.io/documentation/networkx-1.9.1/reference/generated/networkx.algorithms.shortest_paths.weighted.single_source_dijkstra.html single_source_dijkstra]</code>).
* Python/C++: [https://networkit.iti.kit.edu NetworKit] (класс <code>[https://networkit.iti.kit.edu/data/uploads/docs/NetworKit-Doc/python/html/graph.html#networkit.graph.Dijkstra networkit.graph.Dijkstra]</code>).

== Литература ==

<references />

[[Категория:Статьи в работе]]

[[En:Dijkstra's algorithm]]

Алгоритм Δ-шагания

2018-06-14T12:25:57Z

Apaokin:

{{level-a}}

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм дельта-шагания'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> (англ. Δ-Stepping) предназначен для решения [[Поиск кратчайшего пути от одной вершины (SSSP)|задачи поиска кратчайшего пути на графе]]. Для заданного ориентированного взвешенного графа с неотрицательными весами алгоритм находит кратчайшие расстояния от выделенной вершины-источника до всех остальных вершин графа. Алгоритм изначально проектировался с целью эффективной параллелизации.

=== Математическое описание алгоритма ===
=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
Псевдокод последовательного алгоритма:

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'' с весами ''W'';
вершина-источник ''u'';
параметр ''Δ'' > 0.
'''Выходные данные''': расстояния ''d''(''v'') до каждой вершины ''v'' ∈ ''V'' от вершины ''u''.

'''procedure''' DeltaStepping(''V'', ''E'', ''W'', ''u'', ''Δ''):
''LightEdges'' := { e ∈ E | W(e) ≤ Δ }
''HeavyEdges'' := { e ∈ E | W(e) > Δ }
'''for each''' ''v'' ∈ ''V'' '''do''' ''d''(''v'') := ∞
Relax(''u'', 0)
'''while''' any({ ''Buckets''(i) ≠ ∅ }):
''Bucket'' := first({ ''Buckets''(i) ≠ ∅ })
''Deleted'' := ∅
'''while''' ''Bucket'' ≠ ∅:
''Requests'' := FindRequests(''Bucket'', ''LightEdges'')
''Deleted'' := ''Deleted'' ∪ ''Bucket''
''Bucket'' := ∅
RelaxAll(''Requests'')
RelaxAll(FindRequests(''Deleted'', ''HeavyEdges''))

'''procedure''' Relax(''v'', ''x''):
'''if''' ''x'' < ''d''(''v''):
''OldBucket'' := B(⌊''d''(''v'') / ''Δ''⌋)
''NewBucket'' := B(⌊''x'' / ''Δ''⌋)
''OldBucket'' := ''OldBucket'' \ {''v''}
''NewBucket'' := ''NewBucket'' ∪ {''v''}
''d''(''v'') := ''x''

'''procedure''' RelaxAll(''R''):
'''for each''' (''v'', ''x'') ∈ ''R'' '''do''' Relax(''v'', ''x'')

'''function''' FindRequests(''V<nowiki>'</nowiki>'', ''E<nowiki>'</nowiki>''):
'''return''' { (''w'', ''d''(''w'') + ''W''(''v'', ''w'')) | ''v'' ∈ ''V<nowiki>'</nowiki>'' and (''v'', ''w'') ∈ ''E<nowiki>'</nowiki>''}

=== Последовательная сложность алгоритма ===

Средняя последовательная сложность алгоритма на графах со случайными весами <math>O(n + m + dL)</math>, где <math>L</math> – максимальный суммарный вес кратчайшего пути, <math>d</math> – максимальная длина кратчайшего пути.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Средняя время работы параллельного алгоритма на графах со случайными весами на <math>O(n)</math> процессорах составляет <math>O((dL + \ln n) \ln n)</math> со средней работой <math>O(n + m + dL \ln n)</math>

=== Входные и выходные данные алгоритма ===

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Свойства алгоритма===

Предельные случаи алгоритма Δ-шагания:
* при <math>\Delta \to 0</math>: [[алгоритм Дейкстры]];
* при <math>\Delta \to \infty</math>: [[алгоритм Беллмана-Форда]].

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

* C++, MPI: [http://www.boost.org/libs/graph_parallel/doc/html/index.html Parallel Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph_parallel/doc/html/dijkstra_shortest_paths.html#delta-stepping-algorithm delta_stepping_shortest_paths]</code>).
{{Buttonlink|http://top53.parallel.ru/algo_results/implementation/25}}

== Литература ==

<references />

[[Категория:Начатые статьи]]

[[en:Δ-stepping algorithm]]

Поиск кратчайшего пути от одной вершины (SSSP)

2018-06-14T12:22:09Z

Apaokin:

{{level-p}}
<indicator name='toplink'> {{Buttonlink|http://top53.parallel.ru/algo_results/task/29}} </indicator>
== Постановка задачи ==

Пусть задан граф <math>G = (V, E)</math> с весами рёбер <math>f(e)</math> и выделенной вершиной-источником <math>u</math>. Последовательность <math>P(u, v)</math> рёбер <math>e_1 = (u, w_1)</math>, <math>e_2 = (w_1, w_2)</math>, …, <math>e_k = (w_{k-1}, v)</math> называется ''путём'', идущим от вершины <math>u</math> к вершине <math>v</math>. Суммарный вес этого пути равен

:<math>
f(P(u, v)) = \sum_{i = 1}^k f(e_i).
</math>

Требуется для каждой вершины <math>v</math>, достижимой из вершины-источника <math>u</math>, указать путь <math>P^*(u, v)</math>, имеющий наименьший возможный суммарный вес:

:<math>
f^*(v) = f(P^*(u, v)) = \min f(P(u, v)).
</math>

Название задачи на английском языке – «Single Source Shortest Path» (SSSP).

== Варианты задачи ==

Если требуется найти кратчайшие пути не от одной, а от всех вершин - см. [[Поиск кратчайшего пути для всех пар вершин (APSP)|поиск кратчайшего пути для всех пар вершин]].

Задача может быть поставлена как для ориентированного, так и для неориентированного графа. Приведённая постановка задачи применима в обоих случаях.

В зависимости от ограничений на возможные значения весов различают следующие случаи.

* '''Единичные веса'''. В этом случае задача существенно упрощается и может быть решена за линейное время [[Поиск в ширину (BFS)|алгоритмом поиска вширь]].
* '''Положительные целые веса'''. Задача также может быть решена за линейное время<ref name=thorup>Thorup, Mikkel. “Undirected Single-Source Shortest Paths with Positive Integer Weights in Linear Time.” Journal of the ACM 46, no. 3 (May 1, 1999): 362–94. doi:10.1145/316542.316548.</ref> (хотя и с большей константой).
* '''Неотрицательные веса'''. Часто встречающееся на практике ограничение, когда вес ребра соответствует времени или стоимости прохождения участка маршрута и не может быть отрицательным.
* '''Произвольные веса'''. Наиболее общая постановка. Граф не должен содержать циклов с отрицательным суммарным весом, иначе кратчайшего пути не существует.

== Свойства задачи ==

Решение задачи удовлетворяет принципу оптимальности: если путь <math>P^*(u, w)</math> является частью кратчайшего пути <math>P^*(u, v)</math>, то <math>P^*(u, w)</math> является кратчайшим путём от источника <math>u</math> до вершины <math>w</math>.

Принцип оптимальности означает, что для каждой вершины <math>v</math> вместо всего кратчайшего пути <math>P^*(u, v)</math> достаточно хранить его последнее ребро <math>e^*_v</math>. Отсюда следует оценка объёма памяти <math>O(m)</math>.

== Описание входных и выходных данных ==

'''Входные данные''': взвешенный граф <math>(V, E, W)</math> (<math>n</math> вершин <math>v_i</math> и <math>m</math> рёбер <math>e_j = (v^{(1)}_{j}, v^{(2)}_{j})</math> с весами <math>f_j</math>), вершина-источник <math>u</math>.

'''Объём входных данных''': <math>O(m + n)</math>.

'''Выходные данные''' (возможные варианты):
# для каждой вершины <math>v</math> исходного графа – последнее ребро <math>e^*_v = (w, v)</math>, лежащее на кратчайшем пути от вершины <math>u</math> к <math>v</math>, или соответствующая вершина <math>w</math>;
# для каждой вершины <math>v</math> исходного графа – суммарный вес <math>f^*(v)</math> кратчайшего пути от от вершины <math>u</math> к <math>v</math>.

'''Объём выходных данных''': <math>O(n)</math>.

=== Преобразование выходных данных и поиск кратчайшего пути ===

Кратчайший путь от <math>u</math> к <math>v</math> может быть восстановлен за время <math>O(\left |P^*(u, v) \right |)</math>, если, начиная с вершины <math>v</math>, проходить рёбра <math>e^*_w</math> в обратном направлении до тех пор, пока не будет посещена вершина <math>u</math>.

Рёбра <math>e^*_v</math> могут быть восстановлены за время <math>O(m)</math> перебором рёбер для каждой вершины:
:<math>
e^*_v \in \{ (w, v) \in E \mid f^*(v) = f^*(w) + f((v, w)) \}.
</math>
Перебор может осуществляться параллельно.

Для поиска кратчайших расстояний <math>f^*(v)</math> по набору рёбер <math>e^*_v</math>, необходимо построить из них дерево, на котором выполнить [[Поиск в ширину (BFS)|поиск в ширину]] за время <math>O(m)</math> (с возможностью параллелизации).

== Алгоритмы решения задачи ==

* '''[[Поиск в ширину (BFS)]]''' для ориентированных невзвешенных графов, сложность <math>O(m)</math>.
* '''[[Алгоритм Дейкстры]]'''<ref>Dijkstra, E W. “A Note on Two Problems in Connexion with Graphs.” Numerische Mathematik 1, no. 1 (December 1959): 269–71. doi:10.1007/BF01386390.</ref><ref>Fredman, Michael L, and Robert Endre Tarjan. “Fibonacci Heaps and Their Uses in Improved Network Optimization Algorithms.” Journal of the ACM 34, no. 3 (July 1, 1987): 596–615. doi:10.1145/28869.28874.</ref> для ориентированных графов с неотрицательными весами, сложность <math>O(m + n \ln n)</math>.
* '''[[Алгоритм Беллмана-Форда]]'''<ref>Bellman, Richard. “On a Routing Problem.” Quarterly of Applied Mathematics 16 (1958): 87–90.</ref><ref>Ford, L R. Network Flow Theory. Rand.org, RAND Corporation, 1958.</ref><ref>Moore, Edward F. “The Shortest Path Through a Maze,” International Symposium on the Theory of Switching, 285–92, 1959.</ref> для ориентированных графов с произвольными весами, сложность <math>O(mn)</math>.
* '''[[Алгоритм Δ-шагания]]'''<ref>Meyer, U, and P Sanders. “Δ-Stepping: a Parallelizable Shortest Path Algorithm.” Journal of Algorithms 49, no. 1 (October 2003): 114–52. doi:10.1016/S0196-6774(03)00076-2.</ref> для ориентированных графов с неотрицательными весами, средняя сложность на графах со случайными весами <math>O(n + m + dL)</math>, параллельная сложность <math>O((dL + \ln n) \ln n</math> со средней работой <math>O(n + m + dL \ln n)</math>.
* '''Алгоритм Торупа'''<ref name=thorup /> представляет собой теоретическое доказательство возможности решения задачи для неориентированных графов с положительными целыми весами за линейное время <math>O(m)</math>.
* В ориентированном ациклическом графе с произвольными весами время поиска кратчайших путей линейное – <math>O(m + n)</math>, алгоритм основан на топологической сортировке графа.

Обозначения: <math>m</math> – число рёбер, <math>n</math> – число вершин, <math>d</math> – максимальная степень вершины, <math>L</math> – максимальный суммарный вес кратчайшего пути.

Перечисленные алгоритмы могут использоваться и для решения [[Поиск кратчайшего пути для всех пар вершин (APSP)|задачи поиска кратчайшего пути для всех пар вершин графа]] (для этого необходимо запустить соответствующий алгоритм для каждой вершины графа, что при необходимости можно сделать параллельно), при этом оценка сложности умножается на <math>n</math>.

== Ссылки ==

<references />

[[Категория:Статьи в работе]]

[[En: Single Source Shortest Path (SSSP)]]

Классификация алгоритмов

2018-06-14T11:48:09Z

Apaokin:

__TOC__
= Задачи алгебры =
==Матричные и векторные операции==
===Векторные операции===
# {{level|Суммирование сдваиванием}}
## {{level|Нахождение суммы элементов массива сдваиванием}}
## {{level|Нахождение частных сумм элементов массива сдваиванием}}
# {{level|Равномерная норма вектора, вещественная версия, последовательно-параллельный вариант}}
# {{level|Скалярное произведение векторов, вещественная версия, последовательно-параллельный вариант}}
# {{level|Последовательно-параллельный метод суммирования}}
=== Умножения матриц на вектор ===
==== Умножения неособенных матриц на вектор ====
# {{level|Умножение плотной неособенной матрицы на вектор (последовательный вещественный вариант)}}
==== Умножения матриц специального вида на вектор ====
# {{level|Преобразование Фурье}}
## {{level|Быстрое преобразование Фурье для составной размерности}}
### {{level|Быстрое преобразование Фурье для степеней двойки}}
#### {{level|Простой алгоритм Кули-Тьюки быстрого преобразования Фурье для степеней двойки}}
#### {{level|Быстрое преобразование Фурье для чётных степеней двойки}}
### {{level|Быстрое преобразование Фурье для составной размерности с небольшими простыми делителями (2,3,5,7)}}
## {{level|Быстрое преобразование Фурье для простой размерности}}
===Матричные операции===
# {{level|Умножение плотных матриц}}
## {{level|Перемножение плотных неособенных матриц (последовательный вещественный вариант)}}
## {{level|Метод Штрассена}}
==Разложения матриц==
{{level|Задача разложения матриц}}
# {{level|Треугольные разложения}}
## {{level|Метод Гаусса (нахождение LU-разложения)}}
### {{level|LU-разложение методом Гаусса без перестановок}}
#### {{level|LU-разложение методом Гаусса}}
#### {{level|Компактная схема метода Гаусса и её модификации}}
##### {{level|Компактная схема метода Гаусса для плотной матрицы}}
##### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы и её модификации}}
###### {{level|Компактная схема метода Гаусса для трёхдиагональной матрицы, последовательный вариант}}
###### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}
###### {{level|Последовательно-параллельный алгоритм для LU-разложения трёхдиагональной матрицы}}
### {{level|LU-разложение методом Гаусса с перестановками}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по столбцу}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по строке}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по главной диагонали}}
#### {{level|LU-разложение методом Гаусса с выбором ведущего элемента по всей матрице}}
## {{level|Метод Холецкого (нахождение симметричного треугольного разложения)}}
### {{level|Разложение Холецкого (метод квадратного корня)}} базовый точечный вещественный вариант для плотной симметричной положительно-определённой матрицы
# {{level|Известные треугольные разложения для матриц специального вида}}
# {{level|Унитарно-треугольные разложения}}
## {{level|QR-разложения плотных неособенных матриц}}
### {{level|Метод Гивенса (вращений) QR-разложения матрицы}}
#### {{level|Метод Гивенса (вращений) QR-разложения квадратной матрицы (вещественный точечный вариант)}}
### {{level|Метод Хаусхолдера (отражений) QR-разложения матрицы}}
#### {{level|Метод Хаусхолдера (отражений) QR-разложения квадратной матрицы, вещественный точечный вариант}}
### {{level|Метод ортогонализации}}
#### {{level|Классический метод ортогонализации}}
#### {{level|Метод ортогонализации с переортогонализацией}}
### {{level|Метод треугольного разложения матрицы Грама}}
## {{level|Методы QR-разложения плотных хессенберговых матриц}}
### {{level|Метод Гивенса (вращений) QR-разложения хессенберговой матрицы (вещественный вариант)}}
### {{level|Метод Хаусхолдера (отражений) QR-разложения хессенберговой матрицы (вещественный вариант)}}
# {{level|Разложения, содержащие матрицу, подобную исходной}}
## {{level|Разложения, содержащие хессенбергову матрицу, унитарно подобную исходной}}
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|Классический точечный метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
### {{level|Метод Гивенса (вращений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|Классический точечный метод Гивенса (вращений) приведения матрицы к хессенберговой (почти треугольной) форме}}
## {{level|Разложения, содержащие трёхдиагональную матрицу, унитарно подобную исходной}}
### {{level|Метод Хаусхолдера (отражений) приведения к трёхдиагональному виду}}
#### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}
#### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}
### {{level|Метод Гивенса (вращений) приведения матрицы к трёхдиагональной форме}}
## {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
# {{level|Разложения с использованием унитарных преобразований, не содержащие матриц, подобной исходной}}
## {{level|Разложения на две унитарные и одну двухдиагональную матрицы}}
### {{level|Метод Хаусхолдера (отражений) приведения матрицы к двухдиагональной форме}}
### {{level|Метод Гивенса (вращений) приведения матрицы к двухдиагональной форме}}
## {{level|Разложения на две унитарные и одну диагональную матрицы}}
### {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
#### {{level|Методы нахождения сингулярных чисел двухдиагональных матриц}}
##### {{level|Алгоритм dqds нахождения сингулярных чисел двухдиагональной матрицы}}
###### {{level|Итерация алгоритма dqds}}

==Решение систем линейных уравнений==
# {{level|Прямые методы решения СЛАУ}}
## {{level|Linpack benchmark}}
## {{level|Методы решения СЛАУ с матрицами специального вида}}
### {{level|Методы решения СЛАУ с треугольными матрицами}}
#### {{level|Прямая подстановка (вещественный вариант)}}
#### {{level|Обратная подстановка (вещественный вариант)}}
#### {{level|Методы решения СЛАУ с двудиагональными матрицами}}
##### {{level|Прямая и обратная подстановка в СЛАУ с двухдиагональной матрицей}}
##### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}
##### {{level|Последовательно-параллельный вариант обратной подстановки}}
### {{level|Методы решения СЛАУ с трёхдиагональными матрицами}}
#### {{level|Методы, основанные на стандартном LU-разложении матрицы}}
##### {{level|Прогонка}}
###### {{level|Прогонка, точечный вариант}}
###### {{level|Классическая монотонная прогонка, повторный вариант}}
##### {{level|Метод сдваивания Стоуна}}
###### {{level|Алгоритм сдваивания Стоуна для LU-разложения трёхдиагональной матрицы}}
###### {{level|Метод сдваивания Стоуна для решения двудиагональных СЛАУ}}
##### {{level|Последовательно-параллельный вариант решения трёхдиагональной СЛАУ с LU-разложением и обратными подстановками}}
#### Другие методы
##### {{level|Метод редукции}}
###### {{level|Полный метод редукции}}
###### {{level|Повторный метод редукции для новой правой части}}
##### {{level|Встречная прогонка}}
###### {{level|Встречная прогонка, точечный вариант}}
###### {{level|Повторная встречная прогонка, точечный вариант}}
##### {{level|Метод циклической редукции}}
###### {{level|Полный метод циклической редукции}}
###### {{level|Повторный метод циклической редукции для новой правой части}}
##### {{level|Метод окаймления}}
### Методы решения СЛАУ с блочно-треугольными матрицами
#### {{level|Блочная прямая подстановка (вещественный вариант)|Блочная прямая подстановка}}
#### {{level|Блочная обратная подстановка (вещественный вариант)|Блочная обратная подстановка}}
#### Методы решения СЛАУ с блочно-двухдиагональными матрицами
##### {{level|Прямая и обратная подстановка в СЛАУ с блочно-двухдиагональной матрицей}}
##### {{level|Метод сдваивания Стоуна для решения блочно-двухдиагональных СЛАУ}}
##### {{level|Блочный последовательно-параллельный вариант обратной подстановки для решения блочно-двухдиагональных СЛАУ}}
### {{level|Методы решения СЛАУ с блочно-трёхдиагональными матрицами}}
#### Методы, основанные на стандартном LU-разложении матрицы
##### {{level|Блочная прогонка}}
##### {{level|Блочный последовательно-параллельный вариант решения с LU-разложением и обратными подстановками}}
#### Другие методы
##### {{level|Встречная прогонка, блочный вариант}}
##### {{level|Блочный метод циклической редукции}}
##### {{level|Блочный метод окаймления}}
## {{level|Решения СЛАУ с матрицами специального вида, имеющими известные обратные матрицы}}
# Итерационные методы решения СЛАУ
## {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
## {{level|Стабилизированный метод бисопряженных градиентов (BiCGStab)}}
## {{level|Алгоритм_Качмажа}}

==Решения спектральных задач==
# {{level|Спектральное разложение (нахождение собственных значений и векторов)}}
## {{level|QR-алгоритм}}
### {{level|QR-алгоритм, используемый в SCALAPACK}}
#### {{level|Классический точечный метод Хаусхолдера (отражений) приведения матрицы к хессенберговой (почти треугольной) форме}}
#### {{level|QR-алгоритм для хессенберговой матрицы, используемый в SCALAPACK}}
### {{level|QR-алгоритм для симметричных матриц, используемый в SCALAPACK}}
#### {{level|Метод Хаусхолдера (отражений) для приведения симметричных матриц к трёхдиагональному виду}}
#### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}
### {{level|QR-алгоритм для комплексных эрмитовых матриц, используемый в SCALAPACK}}
#### {{level|Метод Хаусхолдера (отражений) для приведения комплексных эрмитовых матриц к трёхдиагональному симметричному виду}}
#### {{level|QR-алгоритм для симметричных трёхдиагональных матриц, используемый в SCALAPACK}}
## {{level|Метод Якоби (вращений) для решения спектральной задачи у симметричных матриц}}
### {{level|Классический метод Якоби (вращений) для симметричных матриц с выбором по всей матрице}}
### {{level|Метод Якоби (вращений) для симметричных матриц с циклическим исключением}}
### {{level|Метод Якоби (вращений) для симметричных матриц с циклическим исключением и барьерами}}
## {{level|Метод Ланцоша}}
### {{level|Алгоритм Ланцоша для точной арифметики (без переортогонализации)}}
# {{level|Частичная спектральная задача}}
## {{level|Метод бисекций}}
# {{level|Сингулярное разложение (нахождение сингулярных значений и векторов)}}
## {{level|Метод Якоби (вращений) для нахождения сингулярных значений неособенных матриц}}
### {{level|Метод Якоби (вращений) для нахождения сингулярных значений с циклическим перебором}}
### {{level|Метод Якоби для нахождения сингулярных значений со специальным подбором вращений}}
## {{level|QR-алгоритм в приложении к сингулярному разложению}}
==Алгебра многочленов==
# {{level|Схема Горнера, вещественная версия, последовательный вариант}}

= Алгоритмы на списках и массивах =
==Алгоритмы поиска==
# {{level|Линейный поиск - находит элемент в любом списке|Линейный поиск}}, <math>O(n)</math>
# {{level|Двоичный поиск - находит элемент в отсортированном списке|Двоичный поиск}}, <math>O(\log(n))</math>
==Алгоритмы сортировки==
# {{level|Сортировка с помощью двоичного дерева}}
# {{level|Сортировка пузырьком}}
# {{level|Сортировка слиянием (последовательный и параллельный варианты)}}
==Алгоритмы на графах==
# Обход графа
## {{level|Поиск в ширину (BFS)}}
## {{level|Поиск в глубину (DFS)}}
# {{level|Поиск кратчайшего пути от одной вершины (SSSP)}} {{Buttonlink|http://top53.parallel.ru/algo_results/task/29}}
## {{level|Поиск в ширину (BFS)}} (для невзвешенных графов)
## {{level|Алгоритм Дейкстры}} {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/5}}
## {{level|Алгоритм Беллмана-Форда}} {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/6}}
## {{level|Алгоритм Δ-шагания}} {{Buttonlink|http://top53.parallel.ru/algo_results/algorithm/2}}
# {{level|Поиск кратчайшего пути для всех пар вершин (APSP)}}
## {{level|Алгоритм Джонсона}}
## {{level|Алгоритм Флойда-Уоршелла}}
# {{level|Поиск транзитивного замыкания орграфа}}
## {{level|Алгоритм Пурдома}}
# {{level|Определение диаметра графа}}
# {{level|Построение минимального остовного дерева (MST)}}
## {{level|Алгоритм Борувки}}
## {{level|Алгоритм Крускала}}
## {{level|Алгоритм Прима}}
## {{level|Алгоритм GHS}}
# {{level|Поиск изоморфных подграфов}}
## {{level|Алгоритм Ульмана}}
## {{level|Алгоритм VF2}}
# {{level|Связность в графах}}
## {{level|Алгоритм Шилоаха-Вишкина поиска компонент связности}}
## {{level|Система непересекающихся множеств}}
## {{level|Алгоритм Тарьяна поиска компонент сильной связности}}
## {{level|Алгоритм DCSC поиска компонент сильной связности}}
## {{level|Алгоритм Тарьяна поиска компонент двусвязности}}
## {{level|Алгоритм Тарьяна-Вишкина поиска компонент двусвязности}}
## {{level|Алгоритм Тарьяна поиска «мостов» в графе}}
## {{level|Определение вершинной связности графа}}
## {{level|Алгоритм Габова определения рёберной связности графа}}
# {{level|Поиск максимального потока в транспортной сети}}
## {{level|Алгоритм Форда-Фалкерсона}}
## {{level|Алгоритм проталкивания предпотока}}
# {{level|Поиск потока минимальной стоимости в транспортной сети}}
# {{level|Задача о назначениях}}
## {{level|Венгерский алгоритм}}
## {{level|Алгоритм аукциона}}
## {{level|Алгоритм Гопкрофта-Карпа}}
# {{level|Вычисление betweenness centrality|Вычисление центральности вершин}}
=Вычислительная геометрия=
# {{level|Поиск диаметра множества точек}}
# {{level|Построение выпуклой оболочки набора точек}}
# {{level|Триангуляция Делоне}}
# {{level|Диаграмма Вороного}}
# {{level|Принадлежность точки многоугольнику}}
# {{level|Пересечения выпуклых многоугольников}}
# {{level|Пересечение звёздных многоугольников}}
==Компьютерная графика==
# {{level|Алгоритмы построения отрезка - алгоритмы для аппроксимации отрезка на дискретной графической поверхности}}
# {{level|Алгоритм определения видимых частей трёхмерной сцены}}
# {{level|Трассировка лучей - рендеринг реалистичных изображений}}
# {{level|Глобальное освещение - рассматривает прямое освещение и отражение от других объектов}}

=Исследование и моделирование компьютеров=
==Тесты производительности компьютеров==
# {{level|High Performance Conjugate Gradient (HPCG) benchmark}}
# {{level|Linpack benchmark}}
==Алгоритмы моделирования квантовых систем==
# {{level|Алгоритмы моделирования квантовых вычислений}}
## {{level|Однокубитное преобразование вектора-состояния}}
## {{level|Двухкубитное преобразование вектора-состояния}}
## {{level|Моделирование квантового преобразования Фурье}}
==Алгоритмы машинного обучения==
# {{level|Алгоритм k средних (k-means)}}
===Нейронные сети===
# {{level|Распознавание образов}}
## {{level|Распознавание текста}}
## {{level|Распознавание речи}}
## {{level|Распознавание лиц}}
===Алгоритмы теории игр===

= Прикладные задачи из разных областей =
==Алгоритмы оптимизации==
# {{level|Линейное программирование}}
# {{level|Симплекс-метод}}
# {{level|Метод ветвей и границ}}
# {{level|Генетические алгоритмы}}
# {{level|Муравьиные алгоритмы}}
# {{level|Комбинированные алгоритмы}}
# {{level|Стохастическое двойственное динамическое программирование (SDDP)}}
==Решение систем нелинейных уравнений==
# {{level|Метод Ньютона для систем нелинейных уравнений}}
==Численные методы интегрирования==
# {{level|Квадратурные формулы}}
# {{level|Квадратурные (кубатурные) методы численного интегрирования по отрезку (многомерному кубу)}}
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод прямоугольников|Метод прямоугольников]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод трапеций|Метод трапеций]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод парабол (метод Симпсона)|Метод парабол (метод Симпсона)]]
## [[Квадратурные_(кубатурные)_методы_численного_интегрирования_по_отрезку_(многомерному_кубу)#Метод Гаусса|Метод Гаусса]]
==Алгоритмы решения уравнений математической физики==
# {{level|Уравнение Пуассона, решение дискретным преобразованием Фурье}}
=Криптографические алгоритмы=
# {{level|Метод встречи посередине}}
=Другие алгоритмы=

[[en:Algorithm classification]]

[[Категория:Алгоритмы|*]]

Шаблон:Buttonlink

2018-06-14T11:41:25Z

Apaokin:

[{{{1}}} <span style="font-size:10px;" class="mw-ui-button mw-ui-progressive">Получить данные</span>]

Шаблон:Buttonlink

2018-06-14T11:32:34Z

Apaokin: Новая страница: «[{{{1}}} <span class="mw-ui-button mw-ui-progressive">Получить данные</span>]»

[{{{1}}} <span class="mw-ui-button mw-ui-progressive">Получить данные</span>]