Поташник Максим. Технология SEQ-MPI. Поиск кратчайших путей из одной вершины (алгоритм Беллмана-Форда). С CRS формой хранения графа. Вариант 23. (#291)

## Описание

- **Задача**: Поиск кратчайших путей из одной вершины (алгоритм
Беллмана-Форда). С CRS формой хранения графа.
- **Вариант**: 23
- **Технология**: SEQ, MPI
- **Описание**:
В работе граф хранится в форме CRS, представляющую из себя набор из трёх
массивов: row_ptr, col_idx, weights.

SEQ: 
Инициализация: расстояние до исходной вершины = 0, до остальных = 1e9.
Выполняет (n-1) итераций, на каждой обрабатываются все рёбра из вершин с
известными расстояниями. Использует два массива расстояний (dist и
dist_next) для корректного обновления за одну итерацию.
MPI:
Граф полностью рассылается на каждый процесс с помощью MPI_BCast, а
нагрузка по обработке вершин графа равномерно распределяется между
процессами. Глобальная синхронизация выполняется через MPI_Allreduce.

---

## Чек-лист

- [x] **Статус CI**: Все CI-задачи (сборка, тесты, генерация отчёта)
успешно проходят на моей ветке в моем форке
- [x] **Директория и именование задачи**: Я создал директорию с именем
`<фамилия>_<первая_буква_имени>_<короткое_название_задачи>`
- [x] **Полное описание задачи**: Я предоставил полное описание задачи в
теле pull request
- [x] **clang-format**: Мои изменения успешно проходят `clang-format`
локально в моем форке (нет ошибок форматирования)
- [x] **clang-tidy**: Мои изменения успешно проходят `clang-tidy`
локально в моем форке (нет предупреждений/ошибок)
- [x] **Функциональные тесты**: Все функциональные тесты успешно
проходят локально на моей машине
- [x] **Тесты производительности**: Все тесты производительности успешно
проходят локально на моей машине
- [x] **Ветка**: Я работаю в ветке, названной точно так же, как
директория моей задачи (например, `nesterov_a_vector_sum`), а не в
`master`
- [x] **Правдивое содержание**: Я подтверждаю, что все сведения,
указанные в этом pull request, являются точными и достоверными

Author: CosmosWanderer

tasks/potashnik_m_short_ways_bellford/common/include/common.hpp

@@ -0,0 +1,96 @@
+#pragma once
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace potashnik_m_short_ways_bellford {
+
+// CRS Graph class
+class Graph {
+ public:
+  int n;
+
+  std::vector<int> row_ptr;
+  std::vector<int> col_ind;
+  std::vector<int> weights;
+  Graph() : n(0) {}
+  explicit Graph(int n_vertices) : n(n_vertices), row_ptr(n_vertices + 1, 0) {}
+
+  void BuildGraph(const std::vector<int> &src, const std::vector<int> &dst, const std::vector<int> &w) {
+    int m = static_cast<int>(src.size());
+
+    for (int i = 0; i < m; i++) {
+      row_ptr[src[i] + 1]++;
+    }
+
+    for (int i = 0; i < n; i++) {
+      row_ptr[i + 1] += row_ptr[i];
+    }
+
+    col_ind.resize(m);
+    weights.resize(m);
+    std::vector<int> cur = row_ptr;
+
+    for (int i = 0; i < m; i++) {
+      int u = src[i];
+      int pos = cur[u]++;
+
+      col_ind[pos] = dst[i];
+      weights[pos] = w[i];
+    }
+  }
+
+  [[nodiscard]] int Begin(int u) const {
+    return row_ptr[u];
+  }
+  [[nodiscard]] int End(int u) const {
+    return row_ptr[u + 1];
+  }
+};
+
+inline void IterateThroughVertex(const Graph &g, int u, const std::vector<int> &dist, std::vector<int> &dist_out) {
+  for (int i = g.Begin(u); i < g.End(u); i++) {
+    int v = g.col_ind[i];
+    int w = g.weights[i];
+
+    int new_dist = dist[u] + w;
+    dist_out[v] = std::min(new_dist, dist_out[v]);
+  }
+}
+
+inline Graph GenerateGraph(int n) {
+  Graph g(n);
+  std::vector<int> src;
+  std::vector<int> dst;
+  std::vector<int> w;
+  int layers = static_cast<int>(std::sqrt(n));
+  layers = std::max(layers, 1);
+  int layer_size = n / layers;
+  for (int lidx = 0; lidx < layers - 1; lidx++) {
+    int start_u = lidx * layer_size;
+    int end_u = (lidx + 1) * layer_size;
+    int start_v = (lidx + 1) * layer_size;
+    int end_v = (lidx + 2) * layer_size;
+    end_v = std::min(end_v, n);
+    for (int uidx = start_u; uidx < end_u; uidx++) {
+      for (int vidx = start_v; vidx < end_v; vidx++) {
+        src.push_back(uidx);
+        dst.push_back(vidx);
+        int weight = ((uidx * 13 + vidx * 7) % 10) + 1;
+        w.push_back(weight);
+      }
+    }
+  }
+  g.BuildGraph(src, dst, w);
+  return g;
+}
+
+using InType = Graph;              // Graph
+using OutType = std::vector<int>;  // Vector of shortest paths
+using TestType = int;              // Amount of vertices
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace potashnik_m_short_ways_bellford

tasks/potashnik_m_short_ways_bellford/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Максим",
+    "last_name": "Поташник",
+    "middle_name": "Ярославович",
+    "group_number": "3823Б1ФИ3",
+    "task_number": "3"
+  }
+}

tasks/potashnik_m_short_ways_bellford/mpi/include/ops_mpi.hpp

@@ -0,0 +1,63 @@
+#pragma once
+
+#include <mpi.h>
+
+#include <vector>
+
+#include "potashnik_m_short_ways_bellford/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace potashnik_m_short_ways_bellford {
+
+class PotashnikMShortWaysBellfordMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit PotashnikMShortWaysBellfordMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+inline void BellmanFordAlgoIterationMpi(const Graph &g, const std::vector<int> &dist, std::vector<int> &dist_next,
+                                        int start, int end) {
+  dist_next = dist;
+  for (int uidx = start; uidx < end; uidx++) {
+    if (dist[uidx] == 1e9) {
+      continue;
+    }
+    IterateThroughVertex(g, uidx, dist, dist_next);
+  }
+}
+
+inline void BellmanFordAlgoMpi(const Graph &g, int source, std::vector<int> &dist) {
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  int size = 0;
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  int n = g.n;
+
+  dist.assign(n, 1e9);
+  if (rank == 0) {
+    dist[source] = 0;
+  }
+
+  MPI_Bcast(dist.data(), n, MPI_INT, 0, MPI_COMM_WORLD);
+
+  std::vector<int> dist_next(n);
+
+  int start = rank * n / size;
+  int end = (rank + 1) * n / size;
+
+  for (int i = 0; i < n - 1; i++) {
+    BellmanFordAlgoIterationMpi(g, dist, dist_next, start, end);
+    MPI_Allreduce(dist_next.data(), dist.data(), n, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
+  }
+}
+
+}  // namespace potashnik_m_short_ways_bellford

tasks/potashnik_m_short_ways_bellford/mpi/src/ops_mpi.cpp

@@ -0,0 +1,35 @@
+#include "potashnik_m_short_ways_bellford/mpi/include/ops_mpi.hpp"
+
+#include <cmath>
+#include <vector>
+
+#include "potashnik_m_short_ways_bellford/common/include/common.hpp"
+
+namespace potashnik_m_short_ways_bellford {
+
+PotashnikMShortWaysBellfordMPI::PotashnikMShortWaysBellfordMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = OutType{};
+}
+
+bool PotashnikMShortWaysBellfordMPI::ValidationImpl() {
+  return true;
+}
+
+bool PotashnikMShortWaysBellfordMPI::PreProcessingImpl() {
+  return true;
+}
+
+bool PotashnikMShortWaysBellfordMPI::RunImpl() {
+  std::vector<int> dist;
+  potashnik_m_short_ways_bellford::BellmanFordAlgoMpi(GetInput(), 0, dist);
+  GetOutput() = dist;
+  return true;
+}
+
+bool PotashnikMShortWaysBellfordMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace potashnik_m_short_ways_bellford

tasks/potashnik_m_short_ways_bellford/report.md

@@ -0,0 +1,140 @@
+# Поиск кратчайших путей из одной вершины (алгоритм Беллмана-Форда). С CRS формой хранения графа.
+- Student: Поташник Максим Ярославович, group 3823Б1ФИ3
+- Technology: SEQ | MPI
+- Variant: 23
+
+## 1. Introduction
+Задача поиска кратчайших путей из одной вершины является одной из базовых задач теории графов. При этом, часто возникает необходимость решать подобные задачи для больших графов, из-за чего большую актуальность обретают алгоритмы, позволяющие выполнить распараллеливание.
+
+Алгоритм Беллмана–Форда обладает высокой вычислительной сложностью, что делает его подходящим кандидатом для распараллеливания. В данной работе исследуется ускорение вычислений при использовании технологии MPI по сравнению с SEQ реализацией.
+
+## 2. Problem statement
+Требуется найти кратчайшие расстояния от фиксированной вершины графа до всех остальных вершин с использованием алгоритма Беллмана–Форда. Граф хранится в форме CRS.
+
+### Входные данные:
+Ориентированный взвешенный граф, представленный в CRS (Compressed Row Storage) формате.
+Граф генерируется детерминированно по заданному числу вершин.
+Источником кратчайших путей является вершина с индексом 0.
+
+### Выходные данные:
+Вектор целых чисел — кратчайшие расстояния от вершины-источника до всех остальных вершин графа.
+
+### 3. Baseline Algorithm (Sequential)
+Для хранения графа в форме CRS реализован класс Graph, который состоит из:
+1. массива row_ptr, задающего границы списков смежности вершин;
+2. массива col_idx, содержащего номера смежных вершин;
+3. массива weights, содержащего веса рёбер.
+
+```
+class Graph {
+ public:
+  int n;                     
+  std::vector<int> row_ptr;  
+  std::vector<int> col_ind;  
+  std::vector<int> weights;  
+};
+```
+
+В обеих реализациях алгоритма (SEQ и MPI) выполняется релаксация рёбер из вершины:
+```
+inline void IterateThroughVertex(const Graph &g, int u, const std::vector<int> &dist, std::vector<int> &dist_out) {
+  for (int i = g.Begin(u); i < g.End(u); i++) {
+    int v = g.col_ind[i];
+    int w = g.weights[i];
+    int new_dist = dist[u] + w;
+    dist_out[v] = std::min(new_dist, dist_out[v]);
+  }
+}
+```
+
+Инициализация: dist[source] = 0, все остальные dist[v] = 1e9
+Повторить (n-1) раз:
+- Для каждой вершины u с dist[u] != 1e9:
+- Для каждого ребра u->v с весом w:
+- dist[v] = min(dist[v], dist[u] + w)
+Результат: dist[v] содержит кратчайшее расстояние от вершины source до v для каждой вершины v
+
+SEQ Алгоритм:
+```
+inline void BellmanFordAlgoSeq(const Graph &g, int source, std::vector<int> &dist) {
+  dist.assign(n, 1e9);     
+  dist[source] = 0;         
+  
+  for (int i = 0; i < n - 1; i++) { 
+    BellmanFordAlgoIterationSeq(g, dist, dist_next);
+    dist.swap(dist_next);  
+  }
+}
+```
+Итерация алгоритма:
+```
+inline void BellmanFordAlgoIterationSeq(const Graph &g, const std::vector<int> &dist, std::vector<int> &dist_next) {
+  int n = g.n;
+  dist_next = dist;
+  for (int uidx = 0; uidx < n; uidx++) {
+    if (dist[uidx] == 1e9) {
+      continue;
+    }
+    IterateThroughVertex(g, uidx, dist, dist_next);
+  }
+}
+```
+
+### 4. Parallelization Scheme
+В параллельной реализации граф полностью реплицируется на каждом процессе, и все процессы хранят одинаковую CRS-структуру графа. Это происходит с помощью операции MPI_BCast.
+Распараллеливание достигается за счёт разделения множества вершин на непересекающиеся диапазоны, при этом каждый MPI-процесс выполняет релаксацию рёбер только для своего диапазона вершин - равномерно распределяется вычислительная нагрузка между процессами.
+После каждой итерации локальные результаты объединяются с помощью операции MPI_Allreduce.
+
+MPI Алгоритм:
+```
+inline void BellmanFordAlgoMpi(const Graph &g, int source, std::vector<int> &dist) {
+  // Подготовка данных 
+
+  int start = rank * n / size;
+  int end = (rank + 1) * n / size;
+  
+  for (int i = 0; i < n - 1; i++) {
+    BellmanFordAlgoIterationMpi(g, dist, dist_next, start, end);
+    MPI_Allreduce(dist_next.data(), dist.data(), n, MPI_INT, MPI_MIN, MPI_COMM_WORLD);
+  }
+}
+```
+Итерация алгоритма:
+```
+inline void BellmanFordAlgoIterationMpi(const Graph &g, const std::vector<int> &dist, std::vector<int> &dist_next, int start, int end) {
+  dist_next = dist;
+  for (int uidx = start; uidx < end; uidx++) {
+    if (dist[uidx] == 1e9) {
+      continue;
+    }
+    IterateThroughVertex(g, uidx, dist, dist_next);
+  }
+}
+```
+
+### 5. Experimental Setup
+- Hardware/OS: 12th gen Intel(R) Core(TM) i5-12450H, 8 ядер, 16 GB RAM, Windows 11 x64
+- Toolchain: compiler, version, build type (Release/RelWithDebInfo)
+    - Cmake 3.28.3
+    - Компилятор: g++ (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
+    - Использовался Docker-контейнер.
+    - Режим сборки: Release.
+- Data: Для замера производительности использовался граф с 7000 вершинами, генерируемый произвольно (но детерминированно). 
+
+## 6. Results and Discussion
+
+### 6.1 Correctness
+Корректность работы проверена с помощью тестов Google Test на графах с кол-вом вершин: 5, 7, 10, 15, 20.
+
+### 6.2 Performance
+| Mode        | Count | Time, s | Speedup | Efficiency |
+|-------------|-------|---------|---------|------------|
+| seq         | 1     | 3.300   | 1.00    | N/A        |
+| mpi         | 2     | 2.030   | 1.63    | 81.5%      |
+| mpi         | 4     | 1.690   | 1.95    | 48.8%      |
+
+## 7. Conclusions
+Эффективность работы mpi версии при 2-х процессах составляет 81.5%, что является хорошим результатом. Эффективность про 4-х процессах - 48.8%, что объясняется накладными расходами на коммуникацию и синхронизацию между процессами.
+
+## 8. References
+1. "Параллельное программирование для кластерных систем" ННГУ им. Лобачевского, ИИТММ