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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:47:27Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>, величины <math>D(W)</math> определяются рекурсивно, <math>D(W)=1</math> для концевых вершин.

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем, производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS], выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально разрабатывался для параллельной реализации, его время работы составляет <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации связанных компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в обратном порядке обходе графа производится при помощи поиска в глубину [5],[6], который должен выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Каждое из вычислений величин <math>L</math>, <math>H</math>, а так же проверка ребер на свойство, является ли каждое их них мостом [8],[9],[10], может выполняться параллельно за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:47:12Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>, величины <math>D(W)</math> определяются рекурсивно,<math>D(W)=1</math> для концевых вершин.

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем, производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS], выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально разрабатывался для параллельной реализации, его время работы составляет <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации связанных компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в обратном порядке обходе графа производится при помощи поиска в глубину [5],[6], который должен выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Каждое из вычислений величин <math>L</math>, <math>H</math>, а так же проверка ребер на свойство, является ли каждое их них мостом [8],[9],[10], может выполняться параллельно за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:45:28Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>, величины <math>D(W)</math> определяются рекурсивно.

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем, производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS], выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально разрабатывался для параллельной реализации, его время работы составляет <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации связанных компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в обратном порядке обходе графа производится при помощи поиска в глубину [5],[6], который должен выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Каждое из вычислений величин <math>L</math>, <math>H</math>, а так же проверка ребер на свойство, является ли каждое их них мостом [8],[9],[10], может выполняться параллельно за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:43:29Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем, производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS], выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально разрабатывался для параллельной реализации, его время работы составляет <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации связанных компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в обратном порядке обходе графа производится при помощи поиска в глубину [5],[6], который должен выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Каждое из вычислений величин <math>L</math>, <math>H</math>, а так же проверка ребер на свойство, является ли каждое их них мостом [8],[9],[10], может выполняться параллельно за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:33:06Z

Elijah: /* Информационный граф */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем, производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS], выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:32:13Z

Elijah: /* Информационный граф */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

В начале работы алгоритм производит инциализацию связанных компонент графа [1], с последующим выделением тривиальных компонент (размера 1 и 2) [2]; затем производится инициализация уровней для всех вершин [3] при помощи последовательных поисков в ширину [4],[BFS] выполняемых до тех пор, пока все вершины не будут размечены различными уровнями.

Далее производится поиск ребер, вошедших в остовное дерево [5], с последовательным построением данного дерева на основе поиска в глубину [6],[7]. После этого друг за другом производится вычисление необходимых метрик для каждой из вершин L, H и D [8],[9]. Перед завершением работы алгоритма на основе данных метрик производится вычисление мостов в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:28:16Z

Elijah: /* Макроструктура алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:26:43Z

Elijah: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение остовного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:19:55Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода <math>N(v) </math>.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T10:19:23Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины <math>N(v) </math> выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T09:45:44Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w) > N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T09:45:27Z

Elijah: /* Математическое описание алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>=N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-11-22T09:44:40Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

[[En:Tarjan-Vishkin biconnected components algorithm]]

Алгоритм DCSC поиска компонент сильной связности

2017-11-22T09:41:53Z

Elijah: /* Масштабируемость алгоритма */

{{algorithm
| name = Алгоритм DCSC поиска компонент сильной связности
| serial_complexity = <math>O(|V| \ln(|V|))</math>
| pf_height = <math>C * O(ln(u))</math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

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

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

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

'''Алгоритм DCSC'''<ref>Fleischer, Lisa K, Bruce Hendrickson, and Ali Pınar. “On Identifying Strongly Connected Components in Parallel.” In Lecture Notes in Computer Science, Volume 1800, Springer, 2000, pp. 505–11. doi:10.1007/3-540-45591-4_68.</ref><ref>McLendon, William, III, Bruce Hendrickson, Steven J Plimpton, and Lawrence Rauchwerger. “Finding Strongly Connected Components in Distributed Graphs.” Journal of Parallel and Distributed Computing 65, no. 8 (August 2005): 901–10. doi:10.1016/j.jpdc.2005.03.007.</ref><ref>Hong, Sungpack, Nicole C Rodia, and Kunle Olukotun. “On Fast Parallel Detection of Strongly Connected Components (SCC) in Small-World Graphs,” Proceeedings of SC'13, 1–11, New York, New York, USA: ACM Press, 2013. doi:10.1145/2503210.2503246.</ref> (англ. Divide and Conquer Strong Components – компоненты сильной связности по принципу «Разделяй и властвуй») находит [[Связность в графах|компоненты сильной связности]] ориентированного графа с ожидаемой работой <math>O(|V| \ln |V|)</math> (при условии ограниченной константой степени вершин).

Также алгоритм носит другое название - Forward-Backward (сокр. FB-algorithm), в основном в литературе, связанной с его GPU-реализациями. <ref> Jiˇr ́ı Barnat, Petr Bauch, Lubosˇ Brim, and Milan Cˇesˇka. Computing Strongly Connected Components in Parallel on CUDA. Faculty of Informatics, Masaryk University, Botanicka ́ 68a, 60200 Brno, Czech Republic. </ref>

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

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

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

=== Математическое описание алгоритма ===
Пусть <math>v</math> – некоторая вершина графа. Определим следующие множества вершин:

⎯ <math>Fwd(v)</math> – вершины, достижимые из <math>v</math> .

⎯ <math>Pred(v)</math> – вершины, из которых достижима <math>v</math> (эквивалентно – вершины, достижимые из <math>v</math> в графе, полученном из <math>G</math> обращением всех рёбер).

Используя эти множества, разобьём все вершины графа на четыре области:

⎯ <math>V_1 = Fwd(v) \cap Pred(v) </math>

⎯ <math>V_2 = Fwd(v) \setminus Pred(v) </math>

⎯ <math>V_3 = Pred(v) \setminus Fwd(v)</math>

⎯ <math>V_4 = V \setminus Pred(v) \setminus Fwd(v)</math>

Тогда можно утверждать следующее:

1. Область <math>V_1</math> является компонентой сильной связности.

2. Любая другая компонента сильной связности полностью содержится в одной из областей <math>V_2</math>, <math>V_3</math>, или <math>V_4</math>.

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

Основными вычислительными операциями алгоритма являются поиск вершин, достижимых из выбранной вершины <math>v</math>, а также поиск вершин, из которых достижима выбранная вершина <math>v</math>. Обе данные операции могут быть реализованы через поиски в ширину, устроенные следующим образом:

1. Вершина <math>v_0</math> помещается в начало очереди и помечается как посещенная.

2. Верхняя вершина <math>v</math> извлекается из очереди. Для всех ребер <math>(v, u)</math>, исходящих из вершины <math>v</math>, проверяется, является ли посещенной вершина <math>u</math>. В случае, если является, вершина <math>u</math> помещается в начало очереди.

3. Происходит переход на шаг 2 до тех пор, пока в очереди есть вершины.

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

Алгоритм DCSC состоит в следующем:

1. Поместить в очередь множество <math>V</math>.

2. Параллельно обрабатывать очередь. Для каждого элемента очереди <math>V</math>:

а) Выбрать произвольную ведущую вершину <math>v \in V</math>.

б) Вычислить множества <math>Fwd(v)</math>, <math>Pred(v)</math> (эти два вычисления можно производить параллельно, кроме того, как указано выше, сами эти вычисления хорошо параллелизуются).

в) Добавить множество <math> V_1</math> в список компонент сильной связности.

г) Добавить множества <math> V_2</math>, <math>V_3</math> и <math>V_4</math> в очередь.

3. Алгоритм завершает работу, когда очередь пуста и не осталось активных процессов-обработчиков.

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

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

1. Пометить все вершины из <math>v \in V</math> активными.

2. Для каждой вершины <math>v</math>вычислить число входящих (<math>in(v)</math>) и исходящих (<math>out(v)</math>) дуг <math>(v, u) \in E</math>, таких, что вершина <math>u</math> - активная.

3. Все вершины <math>v \in V</math> , для которых <math>in(v)</math> или <math>out(v)</math> равно нулю, пометить как неактивные.

4. Переходить на шаг 2, до тех пор, пока число активных вершин не перестанет изменяться.

Кроме того, в зависимости от схемы хранения графа может потребоваться предварительное нахождение транспонированного к нему для более эффективной реализации как шага trim, так и поиска вершин, из которых достижима заданная вершина <math>v</math> в вычислительном ядре алгоритма.

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

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

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'';
'''Выходные данные''': номера компонент сильной связанности ''c(v)'' для каждой вершины ''v'' ∈ ''V''.

<source lang="C++">

compute_scc_with_trim(G)
{
G’ = transpose(G)
G = trim(G)
compute_scc()
}

compute_scc(V, G, G’)
{
p = pivot(V)

fwd = bfs(G, p);
pred = bfs(G’, p);

compute_scc(fwd / pred, G, G’)
compute_scc(pred / fwd, G, G’)
compute_scc(V / pred / fwd, G, G’)
}

pivot(V)
{
return random v in V
}

trim(G)
{
for each v in V(G)
active[v] = true

changes = false
do
{
for each v in V
in_deg(v) = compute_in_degree(v)
out_deg(v) = compute_out_degree(v)

for each v in V
if (in_deg[v] == 0 || out_deg[v] == 0)
active[v] = false
changes = true
} while (!changes)
return active
}

</source>

bfs здесь стандартный поиск в ширину, описанный в соответствующем разделе, результатом которого являются все узлы, достижимые из вершины <math> p </math> в графе <math> G </math>

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

Ожидаемая последовательная сложность алгоритма составляет <math>O(|V| \ln(|V|))</math> при условии, что степень вершин ограничена сверху константой.

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

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

[[file:DCSC_full_ig.png|thumb|center|500px|Рисунок 1. Информационный граф алгоритма DCSC(Forward-Backward-Trim).]]

Итак, алгоритм состоит из первоначального шага Trim, выбора pivot-вершины [1], поиска в ширину в прямом и транспонированном графах (forward и backward BFS), обработки результатов поиска [2], проверки необходимости проведения последующих рекурсивных шагов [3], а также рекурсивных вызовов FB-шага. Далее будут приведены более подробные информационные графы для каждой из частей, а также дана подробная расшифровка соответствующих операций, а в следующем разделе мы оценим ресурс параллелизма для каждой части алгоритма.

На рисунке 2 представлен информационный граф шага Trim.

[[file:DCSC_trim_step.png|thumb|center|500px|Рисунок 2. Информационный граф шага Trim алгоритма DCSC.]]

[1] - выделение памяти под массивы данных числа входящих и исходящих дуг, а также активных вершин

[2] - инциализация переменной наличия изменений

[3] - инициализация массива сильно связанных компонент, а также массива активных вершин.

[4] - установка переменной наличия изменений в позицию "нет изменений"

[5] - обнуление массивов числа входящих и исходящих дуг

[6] - проверка, активны ли вершины на концах каждого ребра, увеличение числа входящих/исходящих дуг для соответствующих вершин, изменение переменной наличия изменений

[7] - проверка активности всех вершин графа

[8] - присваивание номеров сильно связанных компонентам с нулевой степенью входящих или исходящих вершин

[9] - проверка, происходили ли изменения на шаге 6, переход к следующей итерации

Информационный граф этапа поиска в ширину (Forward и Backward BFS) приведен в соответствующем разделе ([[Поиск_в_ширину_(BFS)]]).

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

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

На верхнем уровне алгоритм DCSC может параллельно выполнять FB-шаги, продемонстрированные на рисунке 1. Таким образом, на каждом рекурсивном шаге алгоритма могут рекурсивно порождаться до 3 новых параллельных процессов, общее число которых равно числу сильно связанных компонент графа. Кроме того, поиски в ширину в исходном и транспонированном графах независимы и также могут выполняться параллельно друг с другом. Таким образом, на верхнем уровне может выполняться до <math> 2*u/log|u|</math> параллельных потоков, где <math> u </math> - это число сильно связанных компонент графа. Важно заметить, что вычисления FB-шагов одного уровня (а также всех последующих рекурсивных) абсолютно независимы по данным, так как производятся в непересекающихся множествах вершин графа, поэтому могут производиться в том числе и на различных узлах. Кроме того, составные шаги алгоритма (поиск в ширину и шаг Trim) также имеют значительный потенциал параллелизма, описанный далее.

Этап Trim алгоритма, информационный граф которого приведен на рисунке 2, обладает значительным ресурсом параллелизма: единственной последовательной частью является инициализация массивов и переменных (1)(2), а также проверка условия выхода из цикла (9). Операции (3),(5),(7) и (8) абсолютно независимы и могут производиться параллельно, их число составляет <math>O(|V|)</math>. Проверки и обновления данных в операции (6) также могут производиться параллельно, однако обновления данных должны производиться атомарно. Число операций (6) равно <math>O(E)</math>. Таким образом, почти все операции шага Trim могут выполняться параллельно, при этом число параллельно выполняемых операций составляет <math>|V|</math> или <math>|E|</math>. Учитывая, что величины <math>|V|</math> и <math>|E|</math> для графов большого размера крайне велики, потенциал параллелизма данной части алгоритма очень значителен и достаточен для полной загрузки современных вычислительных узлов/сопроцессоров. Кроме того, операции (3),(5),(7),(8) могут быть успешно векторизованы.

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

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

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

Таким образом, на начальном этапе алгоритма может выполняться <math>O(|V|)</math> или <math>O(|E|)</math> параллельных операций. Далее следует <math>O(log(u))</math> шагов, в каждом из которых в среднем присутствует <math>2*u/O(log(u))</math> поисков в ширину, которые так же обладают внутренним ресурсом параллелизма: каждый поиск в ширину имеет <math>O(|E|)</math> параллельных операций на каждом шаге при квадратическом подходе к параллелизации.

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

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

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой вершины <math>v</math> исходного графа – номер компоненты сильной связанности, в которую входит данная вершина <math> c(v) </math>, вершины, принадлежащие одной компоненте сильно связанности имеют одинаковые номера

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

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма Forward-Backward-Trim согласно методике. Исследование проводилось на суперкомпьютере "Ломоносов-2 Суперкомпьютерного комплекса Московского университета.

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

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

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

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

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

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

* 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/strong_components.html strong_components]</code>), распределённый алгоритм DCSC сочетается с локальным поиском компонент сильной связности [[Алгоритм DCSC поиска компонент сильной связности|алгоритмом Тарьяна]].

== Литература ==

<references />

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

[[En:DCSC algorithm for finding the strongly connected components]]

Алгоритм DCSC поиска компонент сильной связности

2017-11-22T08:37:25Z

Elijah: /* Масштабируемость алгоритма */

{{algorithm
| name = Алгоритм DCSC поиска компонент сильной связности
| serial_complexity = <math>O(|V| \ln(|V|))</math>
| pf_height = <math>C * O(ln(u))</math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

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

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

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

'''Алгоритм DCSC'''<ref>Fleischer, Lisa K, Bruce Hendrickson, and Ali Pınar. “On Identifying Strongly Connected Components in Parallel.” In Lecture Notes in Computer Science, Volume 1800, Springer, 2000, pp. 505–11. doi:10.1007/3-540-45591-4_68.</ref><ref>McLendon, William, III, Bruce Hendrickson, Steven J Plimpton, and Lawrence Rauchwerger. “Finding Strongly Connected Components in Distributed Graphs.” Journal of Parallel and Distributed Computing 65, no. 8 (August 2005): 901–10. doi:10.1016/j.jpdc.2005.03.007.</ref><ref>Hong, Sungpack, Nicole C Rodia, and Kunle Olukotun. “On Fast Parallel Detection of Strongly Connected Components (SCC) in Small-World Graphs,” Proceeedings of SC'13, 1–11, New York, New York, USA: ACM Press, 2013. doi:10.1145/2503210.2503246.</ref> (англ. Divide and Conquer Strong Components – компоненты сильной связности по принципу «Разделяй и властвуй») находит [[Связность в графах|компоненты сильной связности]] ориентированного графа с ожидаемой работой <math>O(|V| \ln |V|)</math> (при условии ограниченной константой степени вершин).

Также алгоритм носит другое название - Forward-Backward (сокр. FB-algorithm), в основном в литературе, связанной с его GPU-реализациями. <ref> Jiˇr ́ı Barnat, Petr Bauch, Lubosˇ Brim, and Milan Cˇesˇka. Computing Strongly Connected Components in Parallel on CUDA. Faculty of Informatics, Masaryk University, Botanicka ́ 68a, 60200 Brno, Czech Republic. </ref>

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

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

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

=== Математическое описание алгоритма ===
Пусть <math>v</math> – некоторая вершина графа. Определим следующие множества вершин:

⎯ <math>Fwd(v)</math> – вершины, достижимые из <math>v</math> .

⎯ <math>Pred(v)</math> – вершины, из которых достижима <math>v</math> (эквивалентно – вершины, достижимые из <math>v</math> в графе, полученном из <math>G</math> обращением всех рёбер).

Используя эти множества, разобьём все вершины графа на четыре области:

⎯ <math>V_1 = Fwd(v) \cap Pred(v) </math>

⎯ <math>V_2 = Fwd(v) \setminus Pred(v) </math>

⎯ <math>V_3 = Pred(v) \setminus Fwd(v)</math>

⎯ <math>V_4 = V \setminus Pred(v) \setminus Fwd(v)</math>

Тогда можно утверждать следующее:

1. Область <math>V_1</math> является компонентой сильной связности.

2. Любая другая компонента сильной связности полностью содержится в одной из областей <math>V_2</math>, <math>V_3</math>, или <math>V_4</math>.

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

Основными вычислительными операциями алгоритма являются поиск вершин, достижимых из выбранной вершины <math>v</math>, а также поиск вершин, из которых достижима выбранная вершина <math>v</math>. Обе данные операции могут быть реализованы через поиски в ширину, устроенные следующим образом:

1. Вершина <math>v_0</math> помещается в начало очереди и помечается как посещенная.

2. Верхняя вершина <math>v</math> извлекается из очереди. Для всех ребер <math>(v, u)</math>, исходящих из вершины <math>v</math>, проверяется, является ли посещенной вершина <math>u</math>. В случае, если является, вершина <math>u</math> помещается в начало очереди.

3. Происходит переход на шаг 2 до тех пор, пока в очереди есть вершины.

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

Алгоритм DCSC состоит в следующем:

1. Поместить в очередь множество <math>V</math>.

2. Параллельно обрабатывать очередь. Для каждого элемента очереди <math>V</math>:

а) Выбрать произвольную ведущую вершину <math>v \in V</math>.

б) Вычислить множества <math>Fwd(v)</math>, <math>Pred(v)</math> (эти два вычисления можно производить параллельно, кроме того, как указано выше, сами эти вычисления хорошо параллелизуются).

в) Добавить множество <math> V_1</math> в список компонент сильной связности.

г) Добавить множества <math> V_2</math>, <math>V_3</math> и <math>V_4</math> в очередь.

3. Алгоритм завершает работу, когда очередь пуста и не осталось активных процессов-обработчиков.

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

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

1. Пометить все вершины из <math>v \in V</math> активными.

2. Для каждой вершины <math>v</math>вычислить число входящих (<math>in(v)</math>) и исходящих (<math>out(v)</math>) дуг <math>(v, u) \in E</math>, таких, что вершина <math>u</math> - активная.

3. Все вершины <math>v \in V</math> , для которых <math>in(v)</math> или <math>out(v)</math> равно нулю, пометить как неактивные.

4. Переходить на шаг 2, до тех пор, пока число активных вершин не перестанет изменяться.

Кроме того, в зависимости от схемы хранения графа может потребоваться предварительное нахождение транспонированного к нему для более эффективной реализации как шага trim, так и поиска вершин, из которых достижима заданная вершина <math>v</math> в вычислительном ядре алгоритма.

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

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

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'';
'''Выходные данные''': номера компонент сильной связанности ''c(v)'' для каждой вершины ''v'' ∈ ''V''.

<source lang="C++">

compute_scc_with_trim(G)
{
G’ = transpose(G)
G = trim(G)
compute_scc()
}

compute_scc(V, G, G’)
{
p = pivot(V)

fwd = bfs(G, p);
pred = bfs(G’, p);

compute_scc(fwd / pred, G, G’)
compute_scc(pred / fwd, G, G’)
compute_scc(V / pred / fwd, G, G’)
}

pivot(V)
{
return random v in V
}

trim(G)
{
for each v in V(G)
active[v] = true

changes = false
do
{
for each v in V
in_deg(v) = compute_in_degree(v)
out_deg(v) = compute_out_degree(v)

for each v in V
if (in_deg[v] == 0 || out_deg[v] == 0)
active[v] = false
changes = true
} while (!changes)
return active
}

</source>

bfs здесь стандартный поиск в ширину, описанный в соответствующем разделе, результатом которого являются все узлы, достижимые из вершины <math> p </math> в графе <math> G </math>

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

Ожидаемая последовательная сложность алгоритма составляет <math>O(|V| \ln(|V|))</math> при условии, что степень вершин ограничена сверху константой.

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

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

[[file:DCSC_full_ig.png|thumb|center|500px|Рисунок 1. Информационный граф алгоритма DCSC(Forward-Backward-Trim).]]

Итак, алгоритм состоит из первоначального шага Trim, выбора pivot-вершины [1], поиска в ширину в прямом и транспонированном графах (forward и backward BFS), обработки результатов поиска [2], проверки необходимости проведения последующих рекурсивных шагов [3], а также рекурсивных вызовов FB-шага. Далее будут приведены более подробные информационные графы для каждой из частей, а также дана подробная расшифровка соответствующих операций, а в следующем разделе мы оценим ресурс параллелизма для каждой части алгоритма.

На рисунке 2 представлен информационный граф шага Trim.

[[file:DCSC_trim_step.png|thumb|center|500px|Рисунок 2. Информационный граф шага Trim алгоритма DCSC.]]

[1] - выделение памяти под массивы данных числа входящих и исходящих дуг, а также активных вершин

[2] - инциализация переменной наличия изменений

[3] - инициализация массива сильно связанных компонент, а также массива активных вершин.

[4] - установка переменной наличия изменений в позицию "нет изменений"

[5] - обнуление массивов числа входящих и исходящих дуг

[6] - проверка, активны ли вершины на концах каждого ребра, увеличение числа входящих/исходящих дуг для соответствующих вершин, изменение переменной наличия изменений

[7] - проверка активности всех вершин графа

[8] - присваивание номеров сильно связанных компонентам с нулевой степенью входящих или исходящих вершин

[9] - проверка, происходили ли изменения на шаге 6, переход к следующей итерации

Информационный граф этапа поиска в ширину (Forward и Backward BFS) приведен в соответствующем разделе ([[Поиск_в_ширину_(BFS)]]).

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

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

На верхнем уровне алгоритм DCSC может параллельно выполнять FB-шаги, продемонстрированные на рисунке 1. Таким образом, на каждом рекурсивном шаге алгоритма могут рекурсивно порождаться до 3 новых параллельных процессов, общее число которых равно числу сильно связанных компонент графа. Кроме того, поиски в ширину в исходном и транспонированном графах независимы и также могут выполняться параллельно друг с другом. Таким образом, на верхнем уровне может выполняться до <math> 2*u/log|u|</math> параллельных потоков, где <math> u </math> - это число сильно связанных компонент графа. Важно заметить, что вычисления FB-шагов одного уровня (а также всех последующих рекурсивных) абсолютно независимы по данным, так как производятся в непересекающихся множествах вершин графа, поэтому могут производиться в том числе и на различных узлах. Кроме того, составные шаги алгоритма (поиск в ширину и шаг Trim) также имеют значительный потенциал параллелизма, описанный далее.

Этап Trim алгоритма, информационный граф которого приведен на рисунке 2, обладает значительным ресурсом параллелизма: единственной последовательной частью является инициализация массивов и переменных (1)(2), а также проверка условия выхода из цикла (9). Операции (3),(5),(7) и (8) абсолютно независимы и могут производиться параллельно, их число составляет <math>O(|V|)</math>. Проверки и обновления данных в операции (6) также могут производиться параллельно, однако обновления данных должны производиться атомарно. Число операций (6) равно <math>O(E)</math>. Таким образом, почти все операции шага Trim могут выполняться параллельно, при этом число параллельно выполняемых операций составляет <math>|V|</math> или <math>|E|</math>. Учитывая, что величины <math>|V|</math> и <math>|E|</math> для графов большого размера крайне велики, потенциал параллелизма данной части алгоритма очень значителен и достаточен для полной загрузки современных вычислительных узлов/сопроцессоров. Кроме того, операции (3),(5),(7),(8) могут быть успешно векторизованы.

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

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

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

Таким образом, на начальном этапе алгоритма может выполняться <math>O(|V|)</math> или <math>O(|E|)</math> параллельных операций. Далее следует <math>O(log(u))</math> шагов, в каждом из которых в среднем присутствует <math>2*u/O(log(u))</math> поисков в ширину, которые так же обладают внутренним ресурсом параллелизма: каждый поиск в ширину имеет <math>O(|E|)</math> параллельных операций на каждом шаге при квадратическом подходе к параллелизации.

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

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

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой вершины <math>v</math> исходного графа – номер компоненты сильной связанности, в которую входит данная вершина <math> c(v) </math>, вершины, принадлежащие одной компоненте сильно связанности имеют одинаковые номера

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

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

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма Forward-Backward-Trim согласно методике. Исследование проводилось на суперкомпьютере "Ломоносов-2 Суперкомпьютерного комплекса Московского университета.

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

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

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

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

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

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

* 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/strong_components.html strong_components]</code>), распределённый алгоритм DCSC сочетается с локальным поиском компонент сильной связности [[Алгоритм DCSC поиска компонент сильной связности|алгоритмом Тарьяна]].

== Литература ==

<references />

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

[[En:DCSC algorithm for finding the strongly connected components]]

Алгоритм DCSC поиска компонент сильной связности

2017-11-22T08:36:04Z

Elijah: /* Масштабируемость алгоритма */

{{algorithm
| name = Алгоритм DCSC поиска компонент сильной связности
| serial_complexity = <math>O(|V| \ln(|V|))</math>
| pf_height = <math>C * O(ln(u))</math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

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

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

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

'''Алгоритм DCSC'''<ref>Fleischer, Lisa K, Bruce Hendrickson, and Ali Pınar. “On Identifying Strongly Connected Components in Parallel.” In Lecture Notes in Computer Science, Volume 1800, Springer, 2000, pp. 505–11. doi:10.1007/3-540-45591-4_68.</ref><ref>McLendon, William, III, Bruce Hendrickson, Steven J Plimpton, and Lawrence Rauchwerger. “Finding Strongly Connected Components in Distributed Graphs.” Journal of Parallel and Distributed Computing 65, no. 8 (August 2005): 901–10. doi:10.1016/j.jpdc.2005.03.007.</ref><ref>Hong, Sungpack, Nicole C Rodia, and Kunle Olukotun. “On Fast Parallel Detection of Strongly Connected Components (SCC) in Small-World Graphs,” Proceeedings of SC'13, 1–11, New York, New York, USA: ACM Press, 2013. doi:10.1145/2503210.2503246.</ref> (англ. Divide and Conquer Strong Components – компоненты сильной связности по принципу «Разделяй и властвуй») находит [[Связность в графах|компоненты сильной связности]] ориентированного графа с ожидаемой работой <math>O(|V| \ln |V|)</math> (при условии ограниченной константой степени вершин).

Также алгоритм носит другое название - Forward-Backward (сокр. FB-algorithm), в основном в литературе, связанной с его GPU-реализациями. <ref> Jiˇr ́ı Barnat, Petr Bauch, Lubosˇ Brim, and Milan Cˇesˇka. Computing Strongly Connected Components in Parallel on CUDA. Faculty of Informatics, Masaryk University, Botanicka ́ 68a, 60200 Brno, Czech Republic. </ref>

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

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

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

=== Математическое описание алгоритма ===
Пусть <math>v</math> – некоторая вершина графа. Определим следующие множества вершин:

⎯ <math>Fwd(v)</math> – вершины, достижимые из <math>v</math> .

⎯ <math>Pred(v)</math> – вершины, из которых достижима <math>v</math> (эквивалентно – вершины, достижимые из <math>v</math> в графе, полученном из <math>G</math> обращением всех рёбер).

Используя эти множества, разобьём все вершины графа на четыре области:

⎯ <math>V_1 = Fwd(v) \cap Pred(v) </math>

⎯ <math>V_2 = Fwd(v) \setminus Pred(v) </math>

⎯ <math>V_3 = Pred(v) \setminus Fwd(v)</math>

⎯ <math>V_4 = V \setminus Pred(v) \setminus Fwd(v)</math>

Тогда можно утверждать следующее:

1. Область <math>V_1</math> является компонентой сильной связности.

2. Любая другая компонента сильной связности полностью содержится в одной из областей <math>V_2</math>, <math>V_3</math>, или <math>V_4</math>.

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

Основными вычислительными операциями алгоритма являются поиск вершин, достижимых из выбранной вершины <math>v</math>, а также поиск вершин, из которых достижима выбранная вершина <math>v</math>. Обе данные операции могут быть реализованы через поиски в ширину, устроенные следующим образом:

1. Вершина <math>v_0</math> помещается в начало очереди и помечается как посещенная.

2. Верхняя вершина <math>v</math> извлекается из очереди. Для всех ребер <math>(v, u)</math>, исходящих из вершины <math>v</math>, проверяется, является ли посещенной вершина <math>u</math>. В случае, если является, вершина <math>u</math> помещается в начало очереди.

3. Происходит переход на шаг 2 до тех пор, пока в очереди есть вершины.

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

Алгоритм DCSC состоит в следующем:

1. Поместить в очередь множество <math>V</math>.

2. Параллельно обрабатывать очередь. Для каждого элемента очереди <math>V</math>:

а) Выбрать произвольную ведущую вершину <math>v \in V</math>.

б) Вычислить множества <math>Fwd(v)</math>, <math>Pred(v)</math> (эти два вычисления можно производить параллельно, кроме того, как указано выше, сами эти вычисления хорошо параллелизуются).

в) Добавить множество <math> V_1</math> в список компонент сильной связности.

г) Добавить множества <math> V_2</math>, <math>V_3</math> и <math>V_4</math> в очередь.

3. Алгоритм завершает работу, когда очередь пуста и не осталось активных процессов-обработчиков.

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

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

1. Пометить все вершины из <math>v \in V</math> активными.

2. Для каждой вершины <math>v</math>вычислить число входящих (<math>in(v)</math>) и исходящих (<math>out(v)</math>) дуг <math>(v, u) \in E</math>, таких, что вершина <math>u</math> - активная.

3. Все вершины <math>v \in V</math> , для которых <math>in(v)</math> или <math>out(v)</math> равно нулю, пометить как неактивные.

4. Переходить на шаг 2, до тех пор, пока число активных вершин не перестанет изменяться.

Кроме того, в зависимости от схемы хранения графа может потребоваться предварительное нахождение транспонированного к нему для более эффективной реализации как шага trim, так и поиска вершин, из которых достижима заданная вершина <math>v</math> в вычислительном ядре алгоритма.

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

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

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'';
'''Выходные данные''': номера компонент сильной связанности ''c(v)'' для каждой вершины ''v'' ∈ ''V''.

<source lang="C++">

compute_scc_with_trim(G)
{
G’ = transpose(G)
G = trim(G)
compute_scc()
}

compute_scc(V, G, G’)
{
p = pivot(V)

fwd = bfs(G, p);
pred = bfs(G’, p);

compute_scc(fwd / pred, G, G’)
compute_scc(pred / fwd, G, G’)
compute_scc(V / pred / fwd, G, G’)
}

pivot(V)
{
return random v in V
}

trim(G)
{
for each v in V(G)
active[v] = true

changes = false
do
{
for each v in V
in_deg(v) = compute_in_degree(v)
out_deg(v) = compute_out_degree(v)

for each v in V
if (in_deg[v] == 0 || out_deg[v] == 0)
active[v] = false
changes = true
} while (!changes)
return active
}

</source>

bfs здесь стандартный поиск в ширину, описанный в соответствующем разделе, результатом которого являются все узлы, достижимые из вершины <math> p </math> в графе <math> G </math>

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

Ожидаемая последовательная сложность алгоритма составляет <math>O(|V| \ln(|V|))</math> при условии, что степень вершин ограничена сверху константой.

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

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

[[file:DCSC_full_ig.png|thumb|center|500px|Рисунок 1. Информационный граф алгоритма DCSC(Forward-Backward-Trim).]]

Итак, алгоритм состоит из первоначального шага Trim, выбора pivot-вершины [1], поиска в ширину в прямом и транспонированном графах (forward и backward BFS), обработки результатов поиска [2], проверки необходимости проведения последующих рекурсивных шагов [3], а также рекурсивных вызовов FB-шага. Далее будут приведены более подробные информационные графы для каждой из частей, а также дана подробная расшифровка соответствующих операций, а в следующем разделе мы оценим ресурс параллелизма для каждой части алгоритма.

На рисунке 2 представлен информационный граф шага Trim.

[[file:DCSC_trim_step.png|thumb|center|500px|Рисунок 2. Информационный граф шага Trim алгоритма DCSC.]]

[1] - выделение памяти под массивы данных числа входящих и исходящих дуг, а также активных вершин

[2] - инциализация переменной наличия изменений

[3] - инициализация массива сильно связанных компонент, а также массива активных вершин.

[4] - установка переменной наличия изменений в позицию "нет изменений"

[5] - обнуление массивов числа входящих и исходящих дуг

[6] - проверка, активны ли вершины на концах каждого ребра, увеличение числа входящих/исходящих дуг для соответствующих вершин, изменение переменной наличия изменений

[7] - проверка активности всех вершин графа

[8] - присваивание номеров сильно связанных компонентам с нулевой степенью входящих или исходящих вершин

[9] - проверка, происходили ли изменения на шаге 6, переход к следующей итерации

Информационный граф этапа поиска в ширину (Forward и Backward BFS) приведен в соответствующем разделе ([[Поиск_в_ширину_(BFS)]]).

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

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

На верхнем уровне алгоритм DCSC может параллельно выполнять FB-шаги, продемонстрированные на рисунке 1. Таким образом, на каждом рекурсивном шаге алгоритма могут рекурсивно порождаться до 3 новых параллельных процессов, общее число которых равно числу сильно связанных компонент графа. Кроме того, поиски в ширину в исходном и транспонированном графах независимы и также могут выполняться параллельно друг с другом. Таким образом, на верхнем уровне может выполняться до <math> 2*u/log|u|</math> параллельных потоков, где <math> u </math> - это число сильно связанных компонент графа. Важно заметить, что вычисления FB-шагов одного уровня (а также всех последующих рекурсивных) абсолютно независимы по данным, так как производятся в непересекающихся множествах вершин графа, поэтому могут производиться в том числе и на различных узлах. Кроме того, составные шаги алгоритма (поиск в ширину и шаг Trim) также имеют значительный потенциал параллелизма, описанный далее.

Этап Trim алгоритма, информационный граф которого приведен на рисунке 2, обладает значительным ресурсом параллелизма: единственной последовательной частью является инициализация массивов и переменных (1)(2), а также проверка условия выхода из цикла (9). Операции (3),(5),(7) и (8) абсолютно независимы и могут производиться параллельно, их число составляет <math>O(|V|)</math>. Проверки и обновления данных в операции (6) также могут производиться параллельно, однако обновления данных должны производиться атомарно. Число операций (6) равно <math>O(E)</math>. Таким образом, почти все операции шага Trim могут выполняться параллельно, при этом число параллельно выполняемых операций составляет <math>|V|</math> или <math>|E|</math>. Учитывая, что величины <math>|V|</math> и <math>|E|</math> для графов большого размера крайне велики, потенциал параллелизма данной части алгоритма очень значителен и достаточен для полной загрузки современных вычислительных узлов/сопроцессоров. Кроме того, операции (3),(5),(7),(8) могут быть успешно векторизованы.

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

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

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

Таким образом, на начальном этапе алгоритма может выполняться <math>O(|V|)</math> или <math>O(|E|)</math> параллельных операций. Далее следует <math>O(log(u))</math> шагов, в каждом из которых в среднем присутствует <math>2*u/O(log(u))</math> поисков в ширину, которые так же обладают внутренним ресурсом параллелизма: каждый поиск в ширину имеет <math>O(|E|)</math> параллельных операций на каждом шаге при квадратическом подходе к параллелизации.

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

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

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой вершины <math>v</math> исходного графа – номер компоненты сильной связанности, в которую входит данная вершина <math> c(v) </math>, вершины, принадлежащие одной компоненте сильно связанности имеют одинаковые номера

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

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

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма Forward-Backward-Trim согласно методике. Исследование проводилось на суперкомпьютере "Ломоносов-2 Суперкомпьютерного комплекса Московского университета.

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

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

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

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

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

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

* 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/strong_components.html strong_components]</code>), распределённый алгоритм DCSC сочетается с локальным поиском компонент сильной связности [[Алгоритм DCSC поиска компонент сильной связности|алгоритмом Тарьяна]].

== Литература ==

<references />

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

[[En:DCSC algorithm for finding the strongly connected components]]

Алгоритм DCSC поиска компонент сильной связности

2017-11-22T08:35:39Z

Elijah: /* Масштабируемость алгоритма */

{{algorithm
| name = Алгоритм DCSC поиска компонент сильной связности
| serial_complexity = <math>O(|V| \ln(|V|))</math>
| pf_height = <math>C * O(ln(u))</math>
| pf_width = <math>O(|E|)</math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>O(|V|)</math>
}}

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

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

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

'''Алгоритм DCSC'''<ref>Fleischer, Lisa K, Bruce Hendrickson, and Ali Pınar. “On Identifying Strongly Connected Components in Parallel.” In Lecture Notes in Computer Science, Volume 1800, Springer, 2000, pp. 505–11. doi:10.1007/3-540-45591-4_68.</ref><ref>McLendon, William, III, Bruce Hendrickson, Steven J Plimpton, and Lawrence Rauchwerger. “Finding Strongly Connected Components in Distributed Graphs.” Journal of Parallel and Distributed Computing 65, no. 8 (August 2005): 901–10. doi:10.1016/j.jpdc.2005.03.007.</ref><ref>Hong, Sungpack, Nicole C Rodia, and Kunle Olukotun. “On Fast Parallel Detection of Strongly Connected Components (SCC) in Small-World Graphs,” Proceeedings of SC'13, 1–11, New York, New York, USA: ACM Press, 2013. doi:10.1145/2503210.2503246.</ref> (англ. Divide and Conquer Strong Components – компоненты сильной связности по принципу «Разделяй и властвуй») находит [[Связность в графах|компоненты сильной связности]] ориентированного графа с ожидаемой работой <math>O(|V| \ln |V|)</math> (при условии ограниченной константой степени вершин).

Также алгоритм носит другое название - Forward-Backward (сокр. FB-algorithm), в основном в литературе, связанной с его GPU-реализациями. <ref> Jiˇr ́ı Barnat, Petr Bauch, Lubosˇ Brim, and Milan Cˇesˇka. Computing Strongly Connected Components in Parallel on CUDA. Faculty of Informatics, Masaryk University, Botanicka ́ 68a, 60200 Brno, Czech Republic. </ref>

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

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

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

=== Математическое описание алгоритма ===
Пусть <math>v</math> – некоторая вершина графа. Определим следующие множества вершин:

⎯ <math>Fwd(v)</math> – вершины, достижимые из <math>v</math> .

⎯ <math>Pred(v)</math> – вершины, из которых достижима <math>v</math> (эквивалентно – вершины, достижимые из <math>v</math> в графе, полученном из <math>G</math> обращением всех рёбер).

Используя эти множества, разобьём все вершины графа на четыре области:

⎯ <math>V_1 = Fwd(v) \cap Pred(v) </math>

⎯ <math>V_2 = Fwd(v) \setminus Pred(v) </math>

⎯ <math>V_3 = Pred(v) \setminus Fwd(v)</math>

⎯ <math>V_4 = V \setminus Pred(v) \setminus Fwd(v)</math>

Тогда можно утверждать следующее:

1. Область <math>V_1</math> является компонентой сильной связности.

2. Любая другая компонента сильной связности полностью содержится в одной из областей <math>V_2</math>, <math>V_3</math>, или <math>V_4</math>.

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

Основными вычислительными операциями алгоритма являются поиск вершин, достижимых из выбранной вершины <math>v</math>, а также поиск вершин, из которых достижима выбранная вершина <math>v</math>. Обе данные операции могут быть реализованы через поиски в ширину, устроенные следующим образом:

1. Вершина <math>v_0</math> помещается в начало очереди и помечается как посещенная.

2. Верхняя вершина <math>v</math> извлекается из очереди. Для всех ребер <math>(v, u)</math>, исходящих из вершины <math>v</math>, проверяется, является ли посещенной вершина <math>u</math>. В случае, если является, вершина <math>u</math> помещается в начало очереди.

3. Происходит переход на шаг 2 до тех пор, пока в очереди есть вершины.

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

Алгоритм DCSC состоит в следующем:

1. Поместить в очередь множество <math>V</math>.

2. Параллельно обрабатывать очередь. Для каждого элемента очереди <math>V</math>:

а) Выбрать произвольную ведущую вершину <math>v \in V</math>.

б) Вычислить множества <math>Fwd(v)</math>, <math>Pred(v)</math> (эти два вычисления можно производить параллельно, кроме того, как указано выше, сами эти вычисления хорошо параллелизуются).

в) Добавить множество <math> V_1</math> в список компонент сильной связности.

г) Добавить множества <math> V_2</math>, <math>V_3</math> и <math>V_4</math> в очередь.

3. Алгоритм завершает работу, когда очередь пуста и не осталось активных процессов-обработчиков.

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

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

1. Пометить все вершины из <math>v \in V</math> активными.

2. Для каждой вершины <math>v</math>вычислить число входящих (<math>in(v)</math>) и исходящих (<math>out(v)</math>) дуг <math>(v, u) \in E</math>, таких, что вершина <math>u</math> - активная.

3. Все вершины <math>v \in V</math> , для которых <math>in(v)</math> или <math>out(v)</math> равно нулю, пометить как неактивные.

4. Переходить на шаг 2, до тех пор, пока число активных вершин не перестанет изменяться.

Кроме того, в зависимости от схемы хранения графа может потребоваться предварительное нахождение транспонированного к нему для более эффективной реализации как шага trim, так и поиска вершин, из которых достижима заданная вершина <math>v</math> в вычислительном ядре алгоритма.

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

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

'''Входные данные''':
граф с вершинами ''V'', рёбрами ''E'';
'''Выходные данные''': номера компонент сильной связанности ''c(v)'' для каждой вершины ''v'' ∈ ''V''.

<source lang="C++">

compute_scc_with_trim(G)
{
G’ = transpose(G)
G = trim(G)
compute_scc()
}

compute_scc(V, G, G’)
{
p = pivot(V)

fwd = bfs(G, p);
pred = bfs(G’, p);

compute_scc(fwd / pred, G, G’)
compute_scc(pred / fwd, G, G’)
compute_scc(V / pred / fwd, G, G’)
}

pivot(V)
{
return random v in V
}

trim(G)
{
for each v in V(G)
active[v] = true

changes = false
do
{
for each v in V
in_deg(v) = compute_in_degree(v)
out_deg(v) = compute_out_degree(v)

for each v in V
if (in_deg[v] == 0 || out_deg[v] == 0)
active[v] = false
changes = true
} while (!changes)
return active
}

</source>

bfs здесь стандартный поиск в ширину, описанный в соответствующем разделе, результатом которого являются все узлы, достижимые из вершины <math> p </math> в графе <math> G </math>

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

Ожидаемая последовательная сложность алгоритма составляет <math>O(|V| \ln(|V|))</math> при условии, что степень вершин ограничена сверху константой.

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

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

[[file:DCSC_full_ig.png|thumb|center|500px|Рисунок 1. Информационный граф алгоритма DCSC(Forward-Backward-Trim).]]

Итак, алгоритм состоит из первоначального шага Trim, выбора pivot-вершины [1], поиска в ширину в прямом и транспонированном графах (forward и backward BFS), обработки результатов поиска [2], проверки необходимости проведения последующих рекурсивных шагов [3], а также рекурсивных вызовов FB-шага. Далее будут приведены более подробные информационные графы для каждой из частей, а также дана подробная расшифровка соответствующих операций, а в следующем разделе мы оценим ресурс параллелизма для каждой части алгоритма.

На рисунке 2 представлен информационный граф шага Trim.

[[file:DCSC_trim_step.png|thumb|center|500px|Рисунок 2. Информационный граф шага Trim алгоритма DCSC.]]

[1] - выделение памяти под массивы данных числа входящих и исходящих дуг, а также активных вершин

[2] - инциализация переменной наличия изменений

[3] - инициализация массива сильно связанных компонент, а также массива активных вершин.

[4] - установка переменной наличия изменений в позицию "нет изменений"

[5] - обнуление массивов числа входящих и исходящих дуг

[6] - проверка, активны ли вершины на концах каждого ребра, увеличение числа входящих/исходящих дуг для соответствующих вершин, изменение переменной наличия изменений

[7] - проверка активности всех вершин графа

[8] - присваивание номеров сильно связанных компонентам с нулевой степенью входящих или исходящих вершин

[9] - проверка, происходили ли изменения на шаге 6, переход к следующей итерации

Информационный граф этапа поиска в ширину (Forward и Backward BFS) приведен в соответствующем разделе ([[Поиск_в_ширину_(BFS)]]).

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

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

На верхнем уровне алгоритм DCSC может параллельно выполнять FB-шаги, продемонстрированные на рисунке 1. Таким образом, на каждом рекурсивном шаге алгоритма могут рекурсивно порождаться до 3 новых параллельных процессов, общее число которых равно числу сильно связанных компонент графа. Кроме того, поиски в ширину в исходном и транспонированном графах независимы и также могут выполняться параллельно друг с другом. Таким образом, на верхнем уровне может выполняться до <math> 2*u/log|u|</math> параллельных потоков, где <math> u </math> - это число сильно связанных компонент графа. Важно заметить, что вычисления FB-шагов одного уровня (а также всех последующих рекурсивных) абсолютно независимы по данным, так как производятся в непересекающихся множествах вершин графа, поэтому могут производиться в том числе и на различных узлах. Кроме того, составные шаги алгоритма (поиск в ширину и шаг Trim) также имеют значительный потенциал параллелизма, описанный далее.

Этап Trim алгоритма, информационный граф которого приведен на рисунке 2, обладает значительным ресурсом параллелизма: единственной последовательной частью является инициализация массивов и переменных (1)(2), а также проверка условия выхода из цикла (9). Операции (3),(5),(7) и (8) абсолютно независимы и могут производиться параллельно, их число составляет <math>O(|V|)</math>. Проверки и обновления данных в операции (6) также могут производиться параллельно, однако обновления данных должны производиться атомарно. Число операций (6) равно <math>O(E)</math>. Таким образом, почти все операции шага Trim могут выполняться параллельно, при этом число параллельно выполняемых операций составляет <math>|V|</math> или <math>|E|</math>. Учитывая, что величины <math>|V|</math> и <math>|E|</math> для графов большого размера крайне велики, потенциал параллелизма данной части алгоритма очень значителен и достаточен для полной загрузки современных вычислительных узлов/сопроцессоров. Кроме того, операции (3),(5),(7),(8) могут быть успешно векторизованы.

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

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

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

Таким образом, на начальном этапе алгоритма может выполняться <math>O(|V|)</math> или <math>O(|E|)</math> параллельных операций. Далее следует <math>O(log(u))</math> шагов, в каждом из которых в среднем присутствует <math>2*u/O(log(u))</math> поисков в ширину, которые так же обладают внутренним ресурсом параллелизма: каждый поиск в ширину имеет <math>O(|E|)</math> параллельных операций на каждом шаге при квадратическом подходе к параллелизации.

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

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

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой вершины <math>v</math> исходного графа – номер компоненты сильной связанности, в которую входит данная вершина <math> c(v) </math>, вершины, принадлежащие одной компоненте сильно связанности имеют одинаковые номера

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

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

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

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

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

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

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

Проведём исследование масштабируемости параллельной реализации алгоритма Forward-Backward-Trim согласно методике. Исследование проводилось на суперкомпьютере "Ломоносов-2 Суперкомпьютерного комплекса Московского университета.

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

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

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

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

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

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

* 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/strong_components.html strong_components]</code>), распределённый алгоритм DCSC сочетается с локальным поиском компонент сильной связности [[Алгоритм DCSC поиска компонент сильной связности|алгоритмом Тарьяна]].

== Литература ==

<references />

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

[[En:DCSC algorithm for finding the strongly connected components]]

Алгоритм Пурдома

2017-11-19T14:10:03Z

Elijah: /* Возможные способы и особенности параллельной реализации алгоритма */

{{algorithm
| name = Алгоритм Пурдома
| serial_complexity = <math>O(|E| + \mu^2)</math>
| pf_height = <math>N/A </math>
| pf_width = <math>N/A</math>
| input_data = <math>O(|E| + |V|)</math>
| output_data = <math>O(|V|^2)</math>
}}

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

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

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(|E| + \mu |V|)</math>, где <math>\mu \le |E|</math> – число [[Связность в графах|компонент сильной связности]] этого графа. Алгоритм может быть модифицирован для проверки принадлежности к транзитивному замыканию множества заданных пар вершин.

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

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

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

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

1. В случае решения задачи проверки принадлежности к транзитивному замыканию множества заданных пар вершин, соотношение объемов различных вычислительных частей алгоритма может быть очень различным и, очевидно, зависит от числа пар входных вершин. Кроме того, данное соотношение может также зависеть от типа входного графа, так как структура и количество сильно-связанных компонент сильно влияют как на время поиска сильно-связанных компонент, так и на время выполнения поисков в ширину. Далее представлена таблица, демонстрирующая процент времени выполнения данных частей для одной из реализаций алгоритма для различных типов графов с числом вершин <math>2^{23}</math> и числом входных пар вершин для проверки, равным 10000.

[[file:Purdom_time_table.png|thumb|center|500px|Рисунок 1. Сравнение времени выполнения различных частей одной из реализаций алгоритма Пурдома.]]

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

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

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

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

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

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(|E|)</math>.

На третьем этапе основной операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>|V|</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматом хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu |V|)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>|V|</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(|E| + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(|E| + \mu |V|)</math> в противном случае.

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

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

[[file:Purdom_ig.png|thumb|center|500px|Рисунок 2. Информационный граф алгоритма Пурдома.]]

[1] - инициализация массива номеров сильно связанных компонент

[Поиск сильно связанных компонент (Tarjan, DCSC, etc)] - независимый блок алгоритма, может быть реализован любым алгоритмом сильно связанных компонент: [[Алгоритм_DCSC_поиска_компонент_сильной_связности|DCSC]], [[Алгоритм_Тарьяна_поиска_компонент_сильной_связности|Тарьяна]] и др. Информационный графы данных алгоритмов могут быть найдены в соответствующих разделах.

[2] - выделение памяти под вершины графа промежуточного представления

[3] - добавление вершин к графу промежуточного представления, каждая вершина соответствует одной сильно-связанной компоненте

[4] - подсчет числа вершин в графе промежуточного представления

[5] - выделение памяти под ребра графа промежуточного представления

[6] - добавление ребер к графу промежуточного представления, связывающих различные сильно связанные компоненты

[7] - подсчет числа ребер в графе промежуточного представления

[8] - проверка номеров сильно связанных компонент для каждой пары сильно связанных компонент

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

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

В данном разделе будет описан ресурс параллелизма, основываясь на информационном графе алгоритма, приведенном на рисунке 2.

Инициализация сильно связанных компонент [1] может производиться параллельно и требует <math>|V|</math> операций.

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

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

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

В случае принадлежности вершин одной пары к одной сильно связанной компоненте производится поиск в ширину [BFS] для каждой соответствующей пары. Данные поиски в ширину также могут выполняться параллельно друг другу, при этом каждый поиск в ширину имеет определенный ресурс параллелизма, описанный в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

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

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

Объем входных и выходных данных зависит от вариации постановки проблемы. Далее будут рассмотрены два случая.

1. Поиск полного транзитивного замыкания

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой пары вершин графа её принадлежность к транзитивному замыканию.

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

2. Проверка принадлежности к транзитивному замыканию для <math>n</math> заранее заданных пар вершин <math>(v_{i}, v_{j})</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>n</math> пар вершин <math>(v_{i}, v_{j})</math>.

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

'''Выходные данные''': для каждой входной пары вершин её принадлежность к транзитивному замыканию.

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

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

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

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

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

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

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

== Литература ==

<references />

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

[[En:Purdom's algorithm]]

Алгоритм Пурдома

2017-11-19T14:08:42Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Пурдома
| serial_complexity = <math>O(|E| + \mu^2)</math>
| pf_height = <math>N/A </math>
| pf_width = <math>N/A</math>
| input_data = <math>O(|E| + |V|)</math>
| output_data = <math>O(|V|^2)</math>
}}

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

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

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(|E| + \mu |V|)</math>, где <math>\mu \le |E|</math> – число [[Связность в графах|компонент сильной связности]] этого графа. Алгоритм может быть модифицирован для проверки принадлежности к транзитивному замыканию множества заданных пар вершин.

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

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

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

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

1. В случае решения задачи проверки принадлежности к транзитивному замыканию множества заданных пар вершин, соотношение объемов различных вычислительных частей алгоритма может быть очень различным и, очевидно, зависит от числа пар входных вершин. Кроме того, данное соотношение может также зависеть от типа входного графа, так как структура и количество сильно-связанных компонент сильно влияют как на время поиска сильно-связанных компонент, так и на время выполнения поисков в ширину. Далее представлена таблица, демонстрирующая процент времени выполнения данных частей для одной из реализаций алгоритма для различных типов графов с числом вершин <math>2^{23}</math> и числом входных пар вершин для проверки, равным 10000.

[[file:Purdom_time_table.png|thumb|center|500px|Рисунок 1. Сравнение времени выполнения различных частей одной из реализаций алгоритма Пурдома.]]

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

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

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

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

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

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(|E|)</math>.

На третьем этапе основной операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>|V|</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматом хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu |V|)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>|V|</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(|E| + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(|E| + \mu |V|)</math> в противном случае.

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

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

[[file:Purdom_ig.png|thumb|center|500px|Рисунок 2. Информационный граф алгоритма Пурдома.]]

[1] - инициализация массива номеров сильно связанных компонент

[Поиск сильно связанных компонент (Tarjan, DCSC, etc)] - независимый блок алгоритма, может быть реализован любым алгоритмом сильно связанных компонент: [[Алгоритм_DCSC_поиска_компонент_сильной_связности|DCSC]], [[Алгоритм_Тарьяна_поиска_компонент_сильной_связности|Тарьяна]] и др. Информационный графы данных алгоритмов могут быть найдены в соответствующих разделах.

[2] - выделение памяти под вершины графа промежуточного представления

[3] - добавление вершин к графу промежуточного представления, каждая вершина соответствует одной сильно-связанной компоненте

[4] - подсчет числа вершин в графе промежуточного представления

[5] - выделение памяти под ребра графа промежуточного представления

[6] - добавление ребер к графу промежуточного представления, связывающих различные сильно связанные компоненты

[7] - подсчет числа ребер в графе промежуточного представления

[8] - проверка номеров сильно связанных компонент для каждой пары сильно связанных компонент

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

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

В данном разделе будет описан ресурс параллелизма, основываясь на информационном графе алгоритма, приведенном на рисунке 2.

Инициализация сильно связанных компонент [1] может производиться параллельно и требует <math>|V|</math> операций.

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

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

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

В случае принадлежности вершин одной пары к одной сильно связанной компоненте производится поиск в ширину [BFS] для каждой соответствующей пары. Данные поиски в ширину также могут выполняться параллельно друг другу, при этом каждый поиск в ширину имеет определенный ресурс параллелизма, описанный в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

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

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

Объем входных и выходных данных зависит от вариации постановки проблемы. Далее будут рассмотрены два случая.

1. Поиск полного транзитивного замыкания

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой пары вершин графа её принадлежность к транзитивному замыканию.

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

2. Проверка принадлежности к транзитивному замыканию для <math>n</math> заранее заданных пар вершин <math>(v_{i}, v_{j})</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>n</math> пар вершин <math>(v_{i}, v_{j})</math>.

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

'''Выходные данные''': для каждой входной пары вершин её принадлежность к транзитивному замыканию.

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

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

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

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

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

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

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

== Литература ==

<references />

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

[[En:Purdom's algorithm]]

Алгоритм Пурдома

2017-11-19T14:07:01Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Пурдома
| serial_complexity = <math>O(|E| + \mu^2)</math>
| pf_height = <math>N/A </math>
| pf_width = <math>N/A</math>
| input_data = <math>O(|E| + |V|)</math>
| output_data = <math>O(|V|^2)</math>
}}

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

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

'''Алгоритм Пурдома'''<ref name=Purdom>Purdom, Paul, Jr. “A Transitive Closure Algorithm.” Bit 10, no. 1 (March 1970): 76–94. doi:10.1007/BF01940892.</ref> находит [[Поиск транзитивного замыкания орграфа|транзитивное замыкание ориентированного графа]] за время <math>O(|E| + \mu |V|)</math>, где <math>\mu \le |E|</math> – число [[Связность в графах|компонент сильной связности]] этого графа. Алгоритм может быть модифицирован для проверки принадлежности к транзитивному замыканию множества заданных пар вершин.

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

Алгоритм основан на следующих свойствах:
# Если вершины <math>v</math> и <math>w</math> принадлежат одной [[Связность в графах|компоненте сильной связности]] графа <math>G</math>, то его транзитивное замыкание <math>G^+</math> содержит рёбра <math>(v, w)</math> и <math>(w, v)</math>.
# Если вершины <math>x</math> и <math>y</math> принадлежат одной компоненте сильной связности графа <math>G</math>, а вершины <math>z</math> и <math>t</math> – другой, то рёбра <math>(x, z)</math>, <math>(x, t)</math>, <math>(y, z)</math>, <math>(y, t)</math> принадлежат или не принадлежат транзитивному замыканию <math>G^+</math> одновременно.

Таким образом, поиск транзитивного замыкания графа <math>G</math> сводится к поиску транзитивного замыкания ациклического графа <math>\tilde G</math>, полученного из <math>G</math> схлопыванием каждой компоненты сильной связности в одну вершину. Транзитивное замыкание ациклического графа вычисляется с использованием топологической сортировки вершин графа.

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

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

1. В случае решения задачи проверки принадлежности к транзитивному замыканию множества заданных пар вершин, соотношение объемов различных вычислительных частей алгоритма может быть очень различным и, очевидно, зависит от числа пар входных вершин. Кроме того, данное соотношение может также зависеть от типа входного графа, так как структура и количество сильно-связанных компонент сильно влияют как на время поиска сильно-связанных компонент, так и на время выполнения поисков в ширину. Далее представлена таблица, демонстрирующая процент времени выполнения данных частей для одной из реализаций алгоритма для различных типов графов с числом вершин <math>2^{23}</math> и числом входных пар вершин для проверки, равным 10000.

[[file:Purdom_time_table.png|thumb|center|500px|Рисунок 1. Сравнение времени выполнения различных частей одной из реализаций алгоритма Пурдома.]]

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

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

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

Вычисления производятся в четыре этапа:

# Найти [[Связность в графах|компоненты сильной связности]] исходного графа, заменить каждую компоненту на одну вершину и удалить образовавшиеся рёбра-петли.
# Выполнить топологическую сортировку полученного ациклического графа <math>\tilde G</math>.
# Вычислить транзитивное замыкание графа <math>\tilde G</math>, двигаясь от вершин с бо́льшими номерами к меньшим.
# По найденному транзитивному замыканию <math>\tilde G</math> восстановить транзитивное замыкание исходного графа.

Последний этап не является обязательным, если рассматривать транзитивное замыкание <math>\tilde G</math> как «упакованное» транзитивное замыкание <math>G</math>.

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

'''1 этап''' (''вычисление компонент сильной связности'') может быть реализован [[Алгоритм Тарьяна поиска компонент сильной связности|алгоритмом Тарьяна]]<ref name=DFS>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref>, находящим компоненты сильной связности в ходе [[Поиск в глубину (DFS)|поиска в глубину]].

'''2 этап''' (''топологическая сортировка'') может быть реализован алгоритмом Кана<ref>Kahn, A B. “Topological Sorting of Large Networks.” Communications of the ACM 5, no. 11 (November 1962): 558–62. doi:10.1145/368996.369025.</ref> либо последовательным применением [[Поиск в глубину (DFS)|поиска в глубину]]<ref name=DFS /> для нумерации вершин в предпорядке.

'''3 этап''' (''транзитивное замыкание'' <math>\tilde G</math>) выполняется следующим алгоритмом:

'''Входные данные''':
ациклический граф 'G'' с вершинами 'V'', пронумерованными в топологическом порядке, и рёбрами ''E''.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for''' ''v'' ∈ ''V'' '''in reverse order''':
'''for each''' (''v'', ''w'') ∈ ''E'' '''do''' ''T''(''v'') := ''T''(''v'') ∪ ''T''(''w'')

'''4 этап''' (''транзитивное замыкание'' <math>G</math>) либо выполняется следующим алгоритмом:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.
'''Выходные данные''':
для каждой вершины ''v'' ∈ ''V'' – набор вершин ''T''(''v''),
так что транзитивное замыкание ''G'' состоит из рёбер (''v'', ''w''), ''v'' ∈ ''V'', ''w'' ∈ ''T''(''v'').

'''for each''' ''v'' ∈ ''V'' '''do''' ''T''(''v'') := { ''v'' }
'''for each''' ''v'' ∈ <math>\tilde V</math>:
'''for each''' ''w'' ∈ <math>\tilde T(v)</math>:
''T''(''v'') := ''T''(''v'') ∪ ''SCC''(''w'')
'''for each''' ''x'' ∈ ''SCC''(''v''):
''T''(''x'') := ''T''(''v'') ''/* присваивание по ссылке */''

либо транзитивное замыкание может строиться по упакованным данным <math>\tilde T(v)</math> одной из следующих функций:

'''Входные данные'''
граф ''G'' с вершинами ''V'';
компоненты сильной связности ''SCC''(''v'') графа ''G'';
отображение ''R''(''v'') вершин графа ''G'' на вершины графа <math>\tilde G</math>;
граф <math>\tilde G</math> с вершинами <math>\tilde V</math>;
транзитивное замыкание <math>\tilde T</math> графа <math>\tilde G</math>.

'''function''' transitive_closure(''v''):
''T'' := { ''v'' }
'''for each''' ''w'' ∈ <math>\tilde T(R(v))</math>:
''T'' := ''T'' ∪ ''SCC''(''w'')
'''return''' ''T''

'''function''' is_in_transitive_closure(''v'', ''w''):
'''return''' ''R''(''w'') ∈ <math>\tilde T(R(v))</math>

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

Первый и второй этап выполняются с помощью поиска в глубину со сложностью <math>O(|E|)</math>.

На третьем этапе основной операцией является объединение списков вершин. В случае хранения списков в отсортированном виде объединение выполняется за линейное время. Количество списков не превосходит <math>|V|</math>, а в каждом списке не более <math>\mu</math> вершин, где <math>\mu</math> – количество компонент сильной связности. Общая сложность тогда составляет <math>O(\mu^2)</math>. Альтернативным форматом хранения списка вершин является битовая маска с такой же общей сложностью.

Сложность четвёртого этапа составляет <math>O(\mu |V|)</math>, так как для каждой из <math>\mu</math> компонент сильной связности за линейное время вычисляется список вершин из не более чем <math>|V|</math> вершин. Поскольку компоненты сильной связности не пересекаются, на данном этапе уже не требуется хранить списки в отсортированном виде.

Таким образом, общая сложность составляет <math>O(|E| + \mu^2)</math>, если не требуется явное построение транзитивного замыкания, или <math>O(|E| + \mu |V|)</math> в противном случае.

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

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

[[file:Purdom_ig.png|thumb|center|500px|Рисунок 2. Информационный граф алгоритма Пурдома.]]

[1] - инициализация массива номеров сильно связанных компонент

[Поиск сильно связанных компонент (Tarjan, DCSC, etc)] - независимый блок алгоритма, может быть реализован любым алгоритмом сильно связанных компонент: [[Алгоритм_DCSC_поиска_компонент_сильной_связности|DCSC]], [[Алгоритм_Тарьяна_поиска_компонент_сильной_связности|Тарьяна]] и др. Информационный графы данных алгоритмов могут быть найдены в соответствующих разделах.

[2] - выделение памяти под вершины графа промежуточного представления

[3] - добавление вершин к графу промежуточного представления, каждая вершина соответствует одной сильно-связанной компоненте

[4] - подсчет числа вершин в графе промежуточного представления

[5] - выделение памяти под ребра графа промежуточного представления

[6] - добавление ребер к графу промежуточного представления, связывающих различные сильно связанные компоненты

[7] - подсчет числа ребер в графе промежуточного представления

[8] - проверка номеров сильно связанных компонент для каждой пары сильно связанных компонент

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

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

В данном разделе будет описан ресурс параллелизма, основываясь на информационном графе алгоритма, приведенном на рисунке 2.

Инициализация сильно связанных компонент [1] может производиться параллельно и требует <math>|V|</math> операций.

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

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

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

В случае принадлежности вершин одной пары к одной сильно связанной компоненте производится поиск в ширину [BFS] для каждой соответствующей пары. Данные поиски в ширину также могут выполняться параллельно друг другу, при этом каждый поиск в ширину имеет определенный ресурс параллелизма, описанный в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

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

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

Объем входных и выходных данных зависит от вариации постановки проблемы. Далее будут рассмотрены два случая.

1. Поиск полного транзитивного замыкания

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные''': для каждой пары вершин графа её принадлежность к транзитивному замыканию.

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

2. Проверка принадлежности к транзитивному замыканию для <math>n</math> заранее заданных пар вершин <math>(v_{i}, v_{j})</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>n</math> пар вершин <math>(v_{i}, v_{j})</math>.

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

'''Выходные данные''': для каждой входной пары вершин её принадлежность к транзитивному замыканию.

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

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

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

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

Для демонстрации эффективности представлены графики времени выполнения различных режимов вычислений в зависимости от размера входного графа.

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

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

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

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.). На представленных графиках по оси X граф с каждым делением увеличивается в два раза, и по представленному графику можно оценивать, на сколько увеличилось время выполнения.
Так же время выполнения можно сравнивать для различных версий, например, последовательной CPU, параллельной CPU или же GPU.
На приведенной диаграмме (рисунок 1) для различных размеров графа (от 2^20 до 2^26) представлено время выполнения трех различных версий: последовательной, параллельной CPU и GPU. Шкала на данной диаграмме логарифмическая.

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

* [http://www.boost.org/libs/graph/doc/ Boost Graph Library] (функция <code>[http://www.boost.org/libs/graph/doc/transitive_closure.html transitive_closure]</code>).

== Литература ==

<references />

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

[[En:Purdom's algorithm]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T14:26:14Z

Elijah: /* Схема реализации последовательного алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

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

После этого производится построение островного дерева при помощи поиска в глубину, с подсчетом величин <math>D(v)</math>.

Затем производятся вычисления величин <math>L</math> и <math>H</math> по формулам, приведенным в пунктах b,c в предыдущем разделе.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T14:07:57Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

Нумерация вершин <math>D(v)</math> в порядке обходе графа поиском в глубину [5],[6] должно выполняться сугубо последовательно за <math>O(|V|)</math> операций, и может, вообще говоря, серьезно снизить производительность реализации на параллельных архитектурах.

Вычисление величин <math>L</math>, <math>H</math> и ребер, являющихся мостами [8],[9],[10] может выполняться каждое за <math>O(|V|)</math> операций.

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

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T13:36:03Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</math> процессорах.

Изначальные инициализации компонент и уровней вершин [1] и [3] могут выполняться параллельно за <math>O(|V|)</math> операций. Шаг трим [2] так же может быть выполнен за <math>O(|E|)</math> параллельных атомарных операций. Поиски в ширину от каждой корневой вершины [4],[BFS] производятся последовательно друг за другом, однако сами поиски в ширину обладают значительным образом параллелизма, описанным в соответствующем [[Поиск_в_ширину_(BFS)|разделе]].

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

'''Входные данные''': граф <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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T13:29:09Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T13:28:11Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T13:24:46Z

Elijah: /* Вычислительное ядро алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

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

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

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

2017-08-15T13:21:19Z

Elijah: /* Входные и выходные данные алгоритма */

{{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].
* 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>).
* 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>).

== Литература ==

<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T13:20:54Z

Elijah: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:21:28Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln(|V|))</math> на <math>O(|V| + |E|)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:20:16Z

Elijah: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

1. <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

2. <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:19:12Z

Elijah:

{{algorithm
| name = Алгоритм Тарьяна-Вишкина поиска компонент двусвязности/мостов в графе
| serial_complexity = <math>O(|V| + |E|)</math>
| pf_height = <math>N/A </math>
| pf_width = <math> O(|V|) </math>
| input_data = <math>O(|V| + |E|)</math>
| output_data = <math>max O(|V|)</math>
}}

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

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

# <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

# <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:17:21Z

Elijah: /* Входные и выходные данные алгоритма */

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</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>O(|V| + |E|)</math>.

'''Выходные данные'''

Список ребер, являющихся мостами в графе.

'''Объём выходных данных''':

# <math>O(|E|)</math> в случае хранения массива принадлежности каждого ребра к множеству мостов в графе

# <math>max O(|V|)</math> в случае хранения мостов в виде списка пар вершин

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:14:15Z

Elijah: /* Информационный граф */

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|600px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D [8],[9]. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T12:13:24Z

Elijah: /* Информационный граф */

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Далее происходит поиск ребер, которые войдут в остовное дерево [5] и последовательное построение данного дерева на основе поиска в глубину [6],[7]. Затем друг за другом вычисляются необходимые метрики для каждой их вершин L, H и D. В конце на основе данных метрик вычисляются мосты в графе [10].

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T11:24:16Z

Elijah: /* Информационный граф */

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:tarjan_vishkin_ig.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

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

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

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

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

* размер графа [2^18 : 2^26].

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

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

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

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

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

== Литература ==
<references />

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

Файл:Tarjan vishkin ig.png

2017-08-15T11:23:38Z

Elijah:

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T11:21:59Z

Elijah: /* Последовательная сложность алгоритма */

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

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

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

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

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

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

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

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(|E| + |V|)</math>.

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

[[file:Tarjan Vishkin.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

Рассмотрим подробнее данный информационный граф: в начале работы алгоритма происходит поиск в ширину (BFS) для построения дерева {1, 2}, затем поиск в глубину для нумерации вершин {3, 4, 5}, а затем подсчет величин Low, Disc {6} и сохранение ответа {7}.

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

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

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

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

Программа, реализующая алгоритм Тарьяна-Вышкина, состоит из двух частей: CPU части, отвечающей за параллельные вычисления на многоядерных CPU, а так же копирование данных на GPU и общее управлениями вычислениями, и GPU части, отвечающей только за вычисления на графическом ускорителе.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Тарьяна-Вишкина согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* размер графа [2^18 : 2^26].

Проведем отдельные исследования масштабируемости вширь реализации алгоритма Тарьяна-Вишкина.

Основной характеристикой для сравнения было выбрано время выполнения, так как производительность (определения как TEPS то есть число ребер графа, которое алгоритм обрабатывает в секунду) для данной операции не отражает реальную эффективность обработки.

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.).

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

[[Категория:Начатые статьи]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T11:21:29Z

Elijah: /* Макроструктура алгоритма */

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

=== Математическое описание алгоритма ===

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln |V|)</math> шагов является систематическое использование операции удвоения указателей.

=== Схема реализации последовательного алгоритма ===
=== Последовательная сложность алгоритма ===

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(m + n)</math>.

=== Информационный граф ===
Далее представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. Информационный граф алгоритма — ориентированный граф, состоящий из вершин, соответствующих операциям алгоритма, и направленных дуг, соответствующих передаче данных (результаты одних операций передаются в качестве аргументов другим операциям) между ними.

[[file:Tarjan Vishkin.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

Рассмотрим подробнее данный информационный граф: в начале работы алгоритма происходит поиск в ширину (BFS) для построения дерева {1, 2}, затем поиск в глубину для нумерации вершин {3, 4, 5}, а затем подсчет величин Low, Disc {6} и сохранение ответа {7}.

=== Ресурс параллелизма алгоритма ===

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===
1. Компонента сильной связности – подграф, любые две вершины которого принадлежат какому-либо циклу, и содержащий все такие циклы для своих вершин.

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

Программа, реализующая алгоритм Тарьяна-Вышкина, состоит из двух частей: CPU части, отвечающей за параллельные вычисления на многоядерных CPU, а так же копирование данных на GPU и общее управлениями вычислениями, и GPU части, отвечающей только за вычисления на графическом ускорителе.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Тарьяна-Вишкина согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* размер графа [2^18 : 2^26].

Проведем отдельные исследования масштабируемости вширь реализации алгоритма Тарьяна-Вишкина.

Основной характеристикой для сравнения было выбрано время выполнения, так как производительность (определения как TEPS то есть число ребер графа, которое алгоритм обрабатывает в секунду) для данной операции не отражает реальную эффективность обработки.

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.).

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

[[Категория:Начатые статьи]]

Алгоритм Тарьяна-Вишкина поиска компонент двусвязности

2017-08-15T11:20:29Z

Elijah: /* Общее описание алгоритма */

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

Параллельный '''алгоритм Тарьяна-Вишкина''' <ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> находит [[Связность в графах|компоненты двухсвязности]] неориентированного графа за время <math>O(\ln |V|)</math> на <math>O(|V| + |E|)</math> процессорах. Алгоритм может быть адаптирован для поиска [[Связность в графах|мостов]]. Эффективность алгоритма Тарьяна-Вишкина подтверждена в последнее время<ref>Edwards, James A, and Uzi Vishkin. “Better Speedups Using Simpler Parallel Programming for Graph Connectivity and Biconnectivity,” PMAM’12, 103–114, New York, USA: ACM Press, 2012. doi:10.1145/2141702.2141714</ref><ref>Guojing Cong, and David A Bader. “An Experimental Study of Parallel Biconnected Components Algorithms on Symmetric Multiprocessors (SMPs),” 45b, IEEE, 2005. doi:10.1109/IPDPS.2005.100.</ref> как на системах архитектуры SMP, так и при вычислениях на GPU.

=== Математическое описание алгоритма ===

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.

2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===

На первом шаге работы алгоритма строится остовный лес графа с использованием модифицированного алгоритма Шилоаха-Вишкина.

Для этого для каждой вершины <math>v</math> определяется указатель на родительскую вершину <math>P(v)</math>; на шаге инициализации <math>P(v):=v</math>. Далее остовный лес строится чередованием двух параллельных операций:

• Удвоение указателей: <math>P(v):=P(P(v))</math> ;

• Соединение: <math>P(P(v)):=P(w)</math>, где <math>v</math> – вершина <math>P</math>-дерева ( <math>P(v)=v</math>на текущем шаге), <math>w</math>– некоторая вершина, для которой существует ребро <math>(v,w)\in E</math>. Ребро помечается, как принадлежащее остовному лесу .

Далее производятся следующие шаги:

• перенумерация вершин в обратном порядке обхода (post-order);

• вычисление количества потомков <math>D(v)</math> для каждой вершины;

• вычисление значений <math>L(v)</math> и <math>H(v)</math> для каждой вершины;

• пометка рёбер <math>v \rightarrow w</math> мостами, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

Основной идеей для обеспечения завершения работы алгоритма за <math>O( \ln n)</math> шагов является систематическое использование операции удвоения указателей.

=== Схема реализации последовательного алгоритма ===
=== Последовательная сложность алгоритма ===

Последовательный вариант алгоритма аналогичен [[Алгоритм Тарьяна поиска компонент двусвязности|алгоритму Тарьяна]]<ref>Tarjan, Robert. “Depth-First Search and Linear Graph Algorithms.” SIAM Journal on Computing 1, no. 2 (1972): 146–60.</ref> и имеет линейную сложность <math>O(m + n)</math>.

=== Информационный граф ===
Далее представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. Информационный граф алгоритма — ориентированный граф, состоящий из вершин, соответствующих операциям алгоритма, и направленных дуг, соответствующих передаче данных (результаты одних операций передаются в качестве аргументов другим операциям) между ними.

[[file:Tarjan Vishkin.png|thumb|center|1000px|Рисунок 1 – Информационный граф алгоритма Тарьяна-Вышкина]]

Рассмотрим подробнее данный информационный граф: в начале работы алгоритма происходит поиск в ширину (BFS) для построения дерева {1, 2}, затем поиск в глубину для нумерации вершин {3, 4, 5}, а затем подсчет величин Low, Disc {6} и сохранение ответа {7}.

=== Ресурс параллелизма алгоритма ===

Алгоритм изначально параллельный, время работы <math>O(\ln n)</math> на <math>O(m + n)</math> процессорах.

=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===
1. Компонента сильной связности – подграф, любые две вершины которого принадлежат какому-либо циклу, и содержащий все такие циклы для своих вершин.

2. Компонента сильной связности является объединением всех циклом, проходящих через её вершины.

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===

Программа, реализующая алгоритм Тарьяна-Вышкина, состоит из двух частей: CPU части, отвечающей за параллельные вычисления на многоядерных CPU, а так же копирование данных на GPU и общее управлениями вычислениями, и GPU части, отвечающей только за вычисления на графическом ускорителе.

=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
Проведём исследование масштабируемости параллельной реализации алгоритма Тарьяна-Вишкина согласно [[Scalability methodology|методике]]. Исследование проводилось на суперкомпьютере "Ломоносов-2 [http://parallel.ru/cluster Суперкомпьютерного комплекса Московского университета].

Набор и границы значений изменяемых [[Глоссарий#Параметры запуска|параметров запуска]] реализации алгоритма:

* размер графа [2^18 : 2^26].

Проведем отдельные исследования масштабируемости вширь реализации алгоритма Тарьяна-Вишкина.

Основной характеристикой для сравнения было выбрано время выполнения, так как производительность (определения как TEPS то есть число ребер графа, которое алгоритм обрабатывает в секунду) для данной операции не отражает реальную эффективность обработки.

Анализируя время выполнения можно оценить, насколько понижается эффективность обработки графа при увеличении его размера (данные перестают помещаться в кэш, в память GPU, узла и т.д.).

[[file:Tarjan vishkin scaling wide.png|thumb|center|700px|Рисунок 2. Параллельная реализация алгоритма Тарьяна-Вишкина масштабируемость вширь: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

[[Категория:Начатые статьи]]

Алгоритм Тарьяна поиска «мостов» в графе

2017-08-15T11:19:11Z

Elijah: /* Последовательная сложность алгоритма */

== Свойства и структура алгоритма ==
=== Общее описание алгоритма ===

'''Алгоритм Тарьяна''' <ref>Tarjan, R Endre. “A Note on Finding the Bridges of a Graph.” Information Processing Letters 2, no. 6 (April 1974): 160–61. doi:10.1016/0020-0190(74)90003-9.</ref> находит [[Связность в графах|мосты]] в неориентированном графе за время <math>O(m)</math>.

Пусть <math>T</math> – дерево в одной из компонент связности графа <math>G.</math>

Выберем корневую вершину и введём обозначения:

• <math>v->w</math>, если в дереве имеется <math>e=(v,w)</math>, и вершина находится дальше от корня <math>r</math>, чем вершина <math>v</math>. Далее будем считать дерево <math>T</math> направленным графом, содержащим рёбра указанного вида.

• <math>v=>w</math>, если в ориентированном дереве <math>T</math> имеется направленный путь от <math>v</math> к <math>w</math>.

• <math>v***w</math>, если в графе <math>G</math> существует ребро <math>e=(v,w)</math>, не принадлежащее дереву <math>T</math>.

• <math>N(v)</math> – нумерация вершин в обратном порядке обхода вершин (post-order).
• <math>D(v)</math> – количество потомков вершины <math>v</math> в ориентированном дереве <math>T</math>, то есть .
• <math>S(v)={w | v => w \or \exist u(v => u \and u***w}</math>

• <math>L(v) = \min S(v)</math>, <math>H(v) = \max S(v)</math>.

Алгоритм Тарьяна основан на следующем свойстве: ребро является мостом тогда и только тогда, когда <math>v->w, H(w) <= N(w), L(w) > N(w) - D(w)</math>

=== Математическое описание алгоритма ===

1. Для каждой компоненты связности графа найти какое-либо остовное дерево <math>T</math>.
2. Перенумеровать вершины <math>T</math> в порядке обратного обхода.

3. В порядке возрастания номера вершины выполнить следующие действия:

a. <math>D(v) := 1+ \sum_{v \rightarrow w}D(w) </math>

b. <math> L(v) := \min { \{N(v) - D(v)+1 \} \cup \{ L(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

c. <math> H(v) := \max { \{ N(v) \} \cup \{ H(w) | v \rightarrow w \} \cup \{ N(w) | v \cdots w \} }</math>

d. Пометить ребро <math>v \rightarrow w</math> мостом, если <math>H(w)<=N(w)</math> и <math>L(w)>N(w)-D(w)</math>.

=== Вычислительное ядро алгоритма ===
=== Макроструктура алгоритма ===
=== Схема реализации последовательного алгоритма ===
=== Последовательная сложность алгоритма ===

Последовательная сложность алгоритма составляет <math>O(|E|)</math>.

=== Информационный граф ===
=== Ресурс параллелизма алгоритма ===

Алгоритм Тарьяна может работать с любым остовным деревом, поэтому можно применить эффективно параллелизуемый [[Поиск в ширину (BFS)|поиск в ширину]]. Последующие вычисления также могут быть параллелизованы.

Параллельный [[Алгоритм Тарьяна-Вишкина поиска компонент двусвязности|алгоритм Тарьяна-Вишкина]]<ref>Tarjan, Robert Endre, and Uzi Vishkin. “An Efficient Parallel Biconnectivity Algorithm.” SIAM Journal on Computing 14, no. 4 (1985): 862–74.</ref> основан на аналогичных вычислениях и может быть адаптирован для поиска мостов.

=== Входные и выходные данные алгоритма ===
=== Свойства алгоритма ===

== Программная реализация алгоритма ==
=== Особенности реализации последовательного алгоритма ===
=== Локальность данных и вычислений ===
==== Локальность реализации алгоритма ====
===== Структура обращений в память и качественная оценка локальности =====
===== Количественная оценка локальности =====
=== Возможные способы и особенности параллельной реализации алгоритма ===
=== Масштабируемость алгоритма и его реализации ===
==== Масштабируемость алгоритма ====
==== Масштабируемость реализации алгоритма ====
=== Динамические характеристики и эффективность реализации алгоритма ===
=== Выводы для классов архитектур ===
=== Существующие реализации алгоритма ===

== Литература ==
<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T11:17:17Z

Elijah:

{{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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T11:16:23Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|V|ln(|V|))</math>
| pf_height = <math>max O(|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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T11:13:30Z

Elijah: /* Ресурс параллелизма алгоритма */

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|V|ln(|V|))</math>
| pf_height = <math>max O(|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>, а высота ЯПФ зависит от числа шагов алгоритма, и ограничена сверху O(|V|).

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T11:11:43Z

Elijah: /* Входные и выходные данные алгоритма */

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|V|ln(|V|))</math>
| pf_height = <math>max O(|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. Информационный граф верхнего уровня параллелизма]]

=== Ресурс параллелизма алгоритма ===

Алгоритму Борувки обладает большим потенциалом параллелизма, так как его основная операция (выбор минимального исходящего ребра во фрагменте) может исполнятся независимо для каждого фрагмента.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T11:10:24Z

Elijah: /* Последовательная сложность алгоритма */

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|V|ln(|V|))</math>
| pf_height = <math>max O(|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. Информационный граф верхнего уровня параллелизма]]

=== Ресурс параллелизма алгоритма ===

Алгоритму Борувки обладает большим потенциалом параллелизма, так как его основная операция (выбор минимального исходящего ребра во фрагменте) может исполнятся независимо для каждого фрагмента.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <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>.

=== Свойства алгоритма ===
# Алгоритм останавливается за конечное число шагов, поскольку на каждом шаге становится по крайней мере на один фрагмент меньше.
# Более того, число фрагментов на каждом шаге уменьшается как минимум вдвое, так что общее число шагов составляет не более <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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Борувки

2017-08-15T08:40:34Z

Elijah:

{{algorithm
| name = Алгоритм Борувки
| serial_complexity = <math>O(|V|ln(|V|))</math>
| pf_height = <math>max O(|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>n</math> вершинами и <math>m</math> рёбрами составляет <math>O(m \ln(n))</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. Информационный граф верхнего уровня параллелизма]]

=== Ресурс параллелизма алгоритма ===

Алгоритму Борувки обладает большим потенциалом параллелизма, так как его основная операция (выбор минимального исходящего ребра во фрагменте) может исполнятся независимо для каждого фрагмента.

=== Входные и выходные данные алгоритма ===
'''Входные данные''': взвешенный граф <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>.

=== Свойства алгоритма ===
# Алгоритм останавливается за конечное число шагов, поскольку на каждом шаге становится по крайней мере на один фрагмент меньше.
# Более того, число фрагментов на каждом шаге уменьшается как минимум вдвое, так что общее число шагов составляет не более <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|Рисунок 9. График загрузки CPU при выполнении алгоритма Борувки]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 10%. Это нормальная картина для программ, запущенных c использованием одного ядра в реализации.

[[file:Boruvka Loadavg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Борувки]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 2. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 2 процессами, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Boruvka L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 40 млн/сек . Интересен факт увеличения числа промахов к концу итерации до уровня в 70 млн/сек.

[[file:Boruvka L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже высокое и находится на уровне 30 млн/сек . На графике промахов второго уровня факт увеличения числа промахов к концу итерации проявляется более явно и увеличивается до значения в 50млн/сек.

[[file:Boruvka L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов L3 в секунду при работе алгоритма Борувки]]

На графике кэш-промахов последнего уровня видно, что число промахов тоже достаточно большое и составляет около 30 млн/сек по всем узлам. Эт указывает на то, что задача очень плохо укладывается в кэш-память, и программа постоянно работает с оперативной памятью, что объясняется очень большим размером использованного графа.

[[file:Boruvka Inf data.png|thumb|center|700px|Рисунок 13. График скорости передачи по сети Infiniband в байт/сек при работе алгоритма Борувки]]

На графике скорости передачи данных по сети Infiniband наблюдается достаточно высокая интенсивность использования сети на кпервом этапе. Это объясняется программной логикой, которая предполагает чтение графа из файла с диска, коммуникации с которым происходят на Ломоносов-2 через выделенную для этих задач сеть Infiniband.

[[file:Boruvka inf pckts.png|thumb|center|700px|Рисунок 14. График скорости передачи по сети 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> сочетают алгоритм Борувки и [[алгоритм Крускала]].

== Литература ==

<references />

[[Категория:Начатые статьи]]

Алгоритм Беллмана-Форда

2017-08-15T07:59:51Z

Elijah: /* Ресурс параллелизма алгоритма */

{{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]]

Чтобы понять структуру обращений в память в верхней части, можно рассмотреть ее еще подробнее. Приведем визуализацию небольшой области фрагмента 1, выделенную на рис. 4 зеленым. Однако в данном случае дальнейшее приближение (рис. 5) не привносит большей ясности: видна нерегулярная структура внутри итерации, характер которой достаточно сложно описать. Но в данном случае этого и не требуется – можно заметить, что по вертикали отложено всего 15 элементов, при этом обращений к ним выполняется гораздо больше. Независимо от структуры обращений, такой профиль обладает очень высокой как пространственной, так и временной локальностью.

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 1]]

А так как основная масса обращений приходится именно на фрагмент 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|Рисунок 2. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 5%. Это достаточно неэффективная картина даже для программ, запущенных c использованием одного ядра в реализации.

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 1. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 1 процессом, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 140 млн/сек это очень высокий показатель, показывающие потенциальную причину неэффективности.

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже крайне высокое и находится на уровне 140 млн/сек, что указывает на крайне неэффективную работу с памятью.

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов 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 />

[[Категория:Начатые статьи]]

Алгоритм Беллмана-Форда

2017-08-15T07:47:42Z

Elijah: /* Информационный граф */

{{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] - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

Верхний уровень параллелизма, как уже говорилось, заключается в параллельном подсчете дистанций для различных вершин-источников, и на рисунке отмечен разными плоскостями.

=== Ресурс параллелизма алгоритма ===

При использовании атомарных операций для вычисления минимума релаксация рёбер может производится параллельно. В этом случае потребуется <math>O(|V|)</math> шагов при использовании <math>O(|E|)</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]]

Чтобы понять структуру обращений в память в верхней части, можно рассмотреть ее еще подробнее. Приведем визуализацию небольшой области фрагмента 1, выделенную на рис. 4 зеленым. Однако в данном случае дальнейшее приближение (рис. 5) не привносит большей ясности: видна нерегулярная структура внутри итерации, характер которой достаточно сложно описать. Но в данном случае этого и не требуется – можно заметить, что по вертикали отложено всего 15 элементов, при этом обращений к ним выполняется гораздо больше. Независимо от структуры обращений, такой профиль обладает очень высокой как пространственной, так и временной локальностью.

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 1]]

А так как основная масса обращений приходится именно на фрагмент 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|Рисунок 2. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 5%. Это достаточно неэффективная картина даже для программ, запущенных c использованием одного ядра в реализации.

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 1. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 1 процессом, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 140 млн/сек это очень высокий показатель, показывающие потенциальную причину неэффективности.

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже крайне высокое и находится на уровне 140 млн/сек, что указывает на крайне неэффективную работу с памятью.

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов 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 />

[[Категория:Начатые статьи]]

Алгоритм Беллмана-Форда

2017-08-14T18:22:48Z

Elijah: /* Ресурс параллелизма алгоритма */

{{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 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. На приведенном далее информационном графе нижний уровень параллелизма обозначен в горизонтальных плоскостях. Множество всех плоскостей представляет собой верхний уровень параллелизма (операции в каждой плоскости могут выполняться параллельно).

Нижний уровень параллелизма на графе алгоритма расположен на уровнях {2 и 3}, соответствующим операциям инициализации массива дистанций (2) и обновления массива c использованием данных массива ребер {3}. Операция {4} - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

Верхний уровень параллелизма, как уже говорилось, заключается в параллельном подсчете дистанций для различных вершин-источников, и на рисунке отмечен разными плоскостями.

=== Ресурс параллелизма алгоритма ===

При использовании атомарных операций для вычисления минимума релаксация рёбер может производится параллельно. В этом случае потребуется <math>O(|V|)</math> шагов при использовании <math>O(|E|)</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]]

Чтобы понять структуру обращений в память в верхней части, можно рассмотреть ее еще подробнее. Приведем визуализацию небольшой области фрагмента 1, выделенную на рис. 4 зеленым. Однако в данном случае дальнейшее приближение (рис. 5) не привносит большей ясности: видна нерегулярная структура внутри итерации, характер которой достаточно сложно описать. Но в данном случае этого и не требуется – можно заметить, что по вертикали отложено всего 15 элементов, при этом обращений к ним выполняется гораздо больше. Независимо от структуры обращений, такой профиль обладает очень высокой как пространственной, так и временной локальностью.

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 1]]

А так как основная масса обращений приходится именно на фрагмент 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|Рисунок 2. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 5%. Это достаточно неэффективная картина даже для программ, запущенных c использованием одного ядра в реализации.

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 1. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 1 процессом, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 140 млн/сек это очень высокий показатель, показывающие потенциальную причину неэффективности.

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже крайне высокое и находится на уровне 140 млн/сек, что указывает на крайне неэффективную работу с памятью.

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов 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 />

[[Категория:Начатые статьи]]

Алгоритм Беллмана-Форда

2017-08-14T18:22:06Z

Elijah: /* Свойства алгоритма */

{{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 представлен информационный граф алгоритма, демонстрирующий описанные уровни параллелизма. На приведенном далее информационном графе нижний уровень параллелизма обозначен в горизонтальных плоскостях. Множество всех плоскостей представляет собой верхний уровень параллелизма (операции в каждой плоскости могут выполняться параллельно).

Нижний уровень параллелизма на графе алгоритма расположен на уровнях {2 и 3}, соответствующим операциям инициализации массива дистанций (2) и обновления массива c использованием данных массива ребер {3}. Операция {4} - проверка того, были ли изменения на последней итерации и выход из цикла, если таковых не было.

[[file:APSP.png|thumb|center|700px|Рисунок 1. Информационный граф обобщенного алгоритма Беллмана-Форда.]]

Верхний уровень параллелизма, как уже говорилось, заключается в параллельном подсчете дистанций для различных вершин-источников, и на рисунке отмечен разными плоскостями.

=== Ресурс параллелизма алгоритма ===

При использовании атомарных операций для вычисления минимума релаксация рёбер может производится параллельно. В этом случае потребуется <math>O(n)</math> шагов при использовании <math>O(m)</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]]

Чтобы понять структуру обращений в память в верхней части, можно рассмотреть ее еще подробнее. Приведем визуализацию небольшой области фрагмента 1, выделенную на рис. 4 зеленым. Однако в данном случае дальнейшее приближение (рис. 5) не привносит большей ясности: видна нерегулярная структура внутри итерации, характер которой достаточно сложно описать. Но в данном случае этого и не требуется – можно заметить, что по вертикали отложено всего 15 элементов, при этом обращений к ним выполняется гораздо больше. Независимо от структуры обращений, такой профиль обладает очень высокой как пространственной, так и временной локальностью.

[[file:bellman_ford_4.png|thumb|center|700px|Рисунок 5. Небольшая часть фрагмента 1]]

А так как основная масса обращений приходится именно на фрагмент 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|Рисунок 2. Параллельная реализация алгоритма Беллмана-Форда масштабируемость различных версий реализации алгоритма: производительность в зависимости от размера графа]]

=== Динамические характеристики и эффективность реализации алгоритма ===
Для проведения экспериментов использовалась реализация алгоритма Беллмана-Форда, реализованная для CPU. Все результаты получены на суперкомпьютере «Ломоносов-2». Использовались процессоры Intel Xeon E5-2697v3, задача решалась для графа большого размера на одном узле.
На рисунках показана эффективность реализации алгоритма Беллмана-Форда, запуск проводился на 1 узле для графа 2^27, выполнялась 1 итерация.
[[file:Bellman-Ford cpu.png|thumb|center|700px|Рисунок 9. График загрузки CPU при выполнении алгоритма Беллмана-Форда]]

На графике загрузки процессора видно, что почти все время работы программы не загружены и средний уровень загрузки составляет около 5%. Это достаточно неэффективная картина даже для программ, запущенных c использованием одного ядра в реализации.

[[file:Bellman-Ford LoadAvg.png|thumb|center|700px|Рисунок 10. График числа процессов, ожидающих вхождения в стадию счета (Loadavg), при работе алгоритма Беллмана-Форда]]

На графике числа процессов, ожидающих вхождения в стадию счета (Loadavg), видно, что на протяжении всей работы программы значение этого параметра постоянно на уровне 1. Это указывает на постоянную загрузку аппаратных ресурсов не более чем 1 процессом, однако их число для узла слишком мало, что с одной стороны может указывать на не очень рациональные использование ресурсов.

[[file:Bellman-Ford L1.png|thumb|center|700px|Рисунок 11. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов первого уровня видно, что число промахов очень высокое и находится на уровне 140 млн/сек это очень высокий показатель, показывающие потенциальную причину неэффективности.

[[file:Bellman-Ford L2.png|thumb|center|700px|Рисунок 12. График кэш-промахов L1 в секунду при работе алгоритма Беллмана-Форда]]

На графике кэш-промахов второго уровня видно, что число промахов достаточно тоже крайне высокое и находится на уровне 140 млн/сек, что указывает на крайне неэффективную работу с памятью.

[[file:Bellman-Ford-L3.png|thumb|center|700px|Рисунок 13. График кэш-промахов 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 />

[[Категория:Начатые статьи]]