Чащин Владимир. Технология SEQ-MPI. Нахождение максимальных значений по строкам матрицы. Вариант 15. (#63)

### Описание
Задача: Нахождение максимальных значений по строкам матрицы
Вариант: 15
Технология: SEQ, MPI
Описание
SEQ:
Алгоритм поиска максимальных значений по строкам матрицы основан на
последовательном проходе по каждой строке. Для каждой строки
последовательно просматриваются все элементы, поддерживается текущее
максимальное значение, после чего результат записывается в
соответствующую позицию выходного вектора.
MPI:
Параллельная версия распределяет строки входной матрицы между
MPI-процессами.
Для каждого процесса по его rank вычисляются индексы start и count —
границы блока строк, назначенных к обработке. Распределение учитывает
возможный остаток при делении числа строк на количество процессов,
поэтому некоторые процессы могут получить больше строк.
Процесс rank 0 отправляет назначенные строки каждому рабочему процессу с
помощью MPI_Send, передавая сначала длину строки, затем её элементы.
Рабочие процессы принимают свои строки через MPI_Recv, формируя
локальную подматрицу.
Каждый процесс независимо вычисляет максимальный элемент в каждой строке
своей локальной подматрицы, формируя локальный вектор максимальных
значений.
Затем выполняется сбор результатов: процесс rank 0 получает локальные
максимумы от остальных процессов через MPI_Recv и размещает их в
соответствующие позиции итогового вектора. Рабочие процессы передают
свои результаты обратно корневому процессу с помощью MPI_Send.
После завершения сборки корневой процесс выполняет MPI_Bcast, чтобы
разослать финальный вектор максимальных значений всем MPI-процессам.
### Чек-лист
- [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: kodt2

tasks/chaschin_v_max_for_each_row/common/include/common.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace chaschin_v_max_for_each_row {
+
+using InType = std::vector<std::vector<float>>;
+using OutType = std::vector<float>;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace chaschin_v_max_for_each_row

tasks/chaschin_v_max_for_each_row/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Владимир",
+    "last_name": "Чащин",
+    "middle_name": "Александрович",
+    "group_number": "3823Б1ФИ3",
+    "task_number": "1"
+  }
+}

tasks/chaschin_v_max_for_each_row/mpi/include/ops_mpi.hpp

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <vector>
+
+#include "chaschin_v_max_for_each_row/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace chaschin_v_max_for_each_row {
+
+class ChaschinVMaxForEachRow : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit ChaschinVMaxForEachRow(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  struct RowRange {
+    int start;
+    int count;
+  };
+
+  static RowRange ComputeRange(int nrows, int rank, int size);
+  static std::vector<std::vector<float>> DistributeRows(const std::vector<std::vector<float>> &mat, int rank, int size,
+                                                        const RowRange &range);
+  static std::vector<float> ComputeLocalMax(const std::vector<std::vector<float>> &local_mat);
+
+  static void GatherResults(std::vector<float> &out, const std::vector<float> &local_out, int rank, int size,
+                            const RowRange &range);
+  static void SendRowsToWorkers(const std::vector<std::vector<float>> &mat, int size);
+  static void ReceiveRowsFromRoot(std::vector<std::vector<float>> &local_mat);
+};
+
+}  // namespace chaschin_v_max_for_each_row

tasks/chaschin_v_max_for_each_row/mpi/src/ops_mpi.cpp

@@ -0,0 +1,184 @@
+#include "chaschin_v_max_for_each_row/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <limits>
+#include <utility>
+#include <vector>
+
+#include "chaschin_v_max_for_each_row/common/include/common.hpp"
+
+namespace chaschin_v_max_for_each_row {
+
+ChaschinVMaxForEachRow::ChaschinVMaxForEachRow(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  auto in_copy = in;
+  GetInput() = std::move(in_copy);
+  this->GetOutput().clear();
+}
+
+bool ChaschinVMaxForEachRow::ValidationImpl() {
+  const auto &in = GetInput();
+
+  if (in.empty()) {
+    return in.empty();
+  }
+
+  if (in[0].empty()) {
+    return in[0].empty();
+  }
+
+  return true;
+}
+
+bool ChaschinVMaxForEachRow::PreProcessingImpl() {
+  return true;
+}
+
+void chaschin_v_max_for_each_row::ChaschinVMaxForEachRow::SendRowsToWorkers(const std::vector<std::vector<float>> &mat,
+                                                                            int size) {
+  for (int pi = 1; pi < size; ++pi) {
+    // Inline ComputeRange
+    int nrows = static_cast<int>(mat.size());
+    int base = nrows / size;
+    int rem = nrows % size;
+    int start = (pi * base) + std::min(pi, rem);
+    int count = base + (pi < rem ? 1 : 0);
+
+    for (int ii = 0; ii < count; ++ii) {
+      const auto &row = mat[start + ii];
+      int len = static_cast<int>(row.size());
+
+      MPI_Send(&len, 1, MPI_INT, pi, 100, MPI_COMM_WORLD);
+      if (len > 0) {
+        MPI_Send(row.data(), len, MPI_FLOAT, pi, 101, MPI_COMM_WORLD);
+      }
+    }
+  }
+}
+
+void chaschin_v_max_for_each_row::ChaschinVMaxForEachRow::ReceiveRowsFromRoot(
+    std::vector<std::vector<float>> &local_mat) {
+  for (auto &row : local_mat) {
+    int len = 0;
+    MPI_Recv(&len, 1, MPI_INT, 0, 100, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+
+    row.resize(len);
+    if (len > 0) {
+      MPI_Recv(row.data(), len, MPI_FLOAT, 0, 101, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+    }
+  }
+}
+
+std::vector<std::vector<float>> chaschin_v_max_for_each_row::ChaschinVMaxForEachRow::DistributeRows(
+    const std::vector<std::vector<float>> &mat, int rank, int size, const RowRange &range) {
+  std::vector<std::vector<float>> local_mat(range.count);
+
+  if (rank == 0) {
+    SendRowsToWorkers(mat, size);
+
+    for (int ii = 0; ii < range.count; ++ii) {
+      local_mat[ii] = mat[range.start + ii];
+    }
+  } else {
+    ReceiveRowsFromRoot(local_mat);
+  }
+
+  return local_mat;
+}
+
+std::vector<float> chaschin_v_max_for_each_row::ChaschinVMaxForEachRow::ComputeLocalMax(
+    const std::vector<std::vector<float>> &local_mat) {
+  std::vector<float> local_out(local_mat.size());
+  for (size_t ii = 0; ii < local_mat.size(); ++ii) {
+    local_out[ii] = local_mat[ii].empty() ? std::numeric_limits<float>::lowest()
+                                          : *std::max_element(local_mat[ii].begin(), local_mat[ii].end());
+  }
+  return local_out;
+}
+
+namespace {
+inline void GetRangeForRank(int rank, int total, int world_size, int &start, int &count) {
+  int base = total / world_size;
+  int rem = total % world_size;
+  start = (rank * base) + std::min(rank, rem);
+  count = base + (rank < rem ? 1 : 0);
+}
+
+inline void RecvRows(int src_rank, std::vector<float> &out, int start, int count) {
+  std::vector<float> tmp(count);
+  MPI_Recv(tmp.data(), count, MPI_FLOAT, src_rank, 2, MPI_COMM_WORLD, MPI_STATUS_IGNORE);
+  std::ranges::copy(tmp, out.begin() + start);
+}
+}  // namespace
+
+void chaschin_v_max_for_each_row::ChaschinVMaxForEachRow::GatherResults(std::vector<float> &out,
+                                                                        const std::vector<float> &local_out, int rank,
+                                                                        int size, const RowRange &range) {
+  if (rank != 0) {
+    if (!local_out.empty()) {
+      MPI_Send(local_out.data(), static_cast<int>(local_out.size()), MPI_FLOAT, 0, 2, MPI_COMM_WORLD);
+    }
+    return;
+  }
+
+  for (int i = 0; i < range.count; ++i) {
+    out[range.start + i] = local_out[i];
+  }
+
+  int total = static_cast<int>(out.size());
+  for (int pi = 1; pi < size; ++pi) {
+    int start = 0;
+    int count = 0;
+
+    GetRangeForRank(pi, total, size, start, count);
+    if (count > 0) {
+      RecvRows(pi, out, start, count);
+    }
+  }
+}
+
+bool ChaschinVMaxForEachRow::RunImpl() {
+  int rank = 0;
+  int size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  const auto &mat = GetInput();
+  int nrows = (rank == 0) ? static_cast<int>(mat.size()) : 0;
+  MPI_Bcast(&nrows, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  int base = nrows / size;
+  int rem = nrows % size;
+  int start = (rank * base) + std::min(rank, rem);
+  int count = base + (rank < rem ? 1 : 0);
+  RowRange range{.start = start, .count = count};
+
+  auto local_mat = DistributeRows(mat, rank, size, range);
+  auto local_out = ComputeLocalMax(local_mat);
+
+  if (rank == 0) {
+    GetOutput().resize(nrows);
+  }
+  GatherResults(GetOutput(), local_out, rank, size, range);
+
+  auto &out = GetOutput();
+  if (rank != 0) {
+    out.resize(nrows);
+  }
+
+  if (nrows > 0) {
+    MPI_Bcast(out.data(), nrows, MPI_FLOAT, 0, MPI_COMM_WORLD);
+  }
+
+  return true;
+}
+
+bool ChaschinVMaxForEachRow::PostProcessingImpl() {
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  return true;
+}
+}  // namespace chaschin_v_max_for_each_row

tasks/chaschin_v_max_for_each_row/report.md

@@ -0,0 +1,132 @@
+# Поиск максимального значения в каждой строке матрицы
+
+- Студент: Чащин Владимир Александрович, группа 3823Б1ФИ3
+- Технология: SEQ, MPI
+- Вариант: 15
+
+## 1. Введение
+
+Обработка больших матриц — фундаментальная задача во множестве вычислительных областей. Одним из базовых примитивов является поиск экстремальных значений по строкам или столбцам, который широко используется в статистике, линейной алгебре, анализе данных и машинном обучении.
+
+Задачи такого типа обладают выраженной структурой, но часто плохо масштабируются при параллелизации из-за малого объёма вычислений на единицу данных: вычисление максимума в строке — операция линейной сложности с крайне низкими вычислительными затратами на элемент.
+
+Цель работы — реализовать последовательную и параллельную MPI-версии поиска максимума в каждой строке квадратной матрицы и исследовать поведение этих реализаций на больших входах, проанализировать их эффективность и определить причины, влияющие на масштабируемость.
+## 2. Постановка задачи
+
+**Дано:** матрица `N × N`, элементы — числа с плавающей точкой (тип `float`).
+
+**Требуется:** построить вектор длины `N`, где каждый элемент — максимальный элемент соответствующей строки матрицы.
+
+**Входные данные:** `std::vector<std::vector<float>>` — двумерная матрица.
+**Выходные данные:** `std::vector<float>` — вектор максимальных значений. 
+Матрица гарантированно квадратная, строки могут иметь любую длину, включая крайние случаи: 0 и 1 элемент.
+
+**Ограничения:** Матрица и её строки могут быть непустыми. Реализация должна корректно обрабатывать случаи, когда количество строк не делится нацело на количество используемых процессов.
+
+## 3. Последовательный алгоритм
+
+Последовательный алгоритм представляет собой прямой одномерный проход по каждой строке с поиском максимума.
+## Анализ алгоритма
+* На каждую строку выполняется вызов `std::max_element`, который работает за `O(N)` и хорошо оптимизируется компилятором.
+* Общая сложность — `O(N²)` для матрицы `N×N`.
+* Вычислительных операций мало, основная задержка — чтение элементов из памяти.
+* Современные компиляторы (включая Intel C++ Compiler 2025) легко векторизуют такие циклы, что делает последовательную версию очень быстрой.
+Алгоритм имеет временную сложность O(M * N), так как требует полного обхода всех элементов матрицы.
+* Важное следствие: при попытках распараллеливания на высокоуровневых технологиях типа MPI вычисления часто оказываются быстрее, чем коммуникации.
+Данный факт определяет ограничение масштабируемости MPI-версии.
+
+## 4. Схема распараллеливания
+
+Используется классическая модель Master–Worker.
+
+## Разбиение строк (анализ)
+
+Процесс 0 вычисляет диапазон строк для каждого процесса:
+* `base = N / size` — минимальное число строк на процесс
+* `rem = N % size` — остаток, который равномерно распределяется между первыми процессами
+Таким образом, распределение сбалансировано и обеспечивает почти равное количество строк на каждый процесс.
+
+## Передача данных
+Алгоритм распределения данных работает следующим образом:
+
+1.	Определение диапазона строк для каждого процесса.
+	* Сначала вычисляется, сколько строк матрицы должно достаться каждому процессу.
+	* Если общее количество строк не делится нацело на число процессов, остаток распределяется по одному на первые процессы.
+
+2. Отправка строк рабочим процессам.
+	* Процесс с рангом 0 (Мастер) последовательно проходит по всем рабочим процессам.
+	* Для каждого процесса мастер отправляет сначала длину строки, затем саму строку чисел.
+	* Каждая строка передаётся отдельно, чтобы рабочий процесс точно знал, сколько элементов ему принимать.
+
+3. Получение данных на стороне рабочих процессов.
+	* Каждый рабочий процесс получает длину строки.
+	* После этого создаётся буфер нужного размера, и в него принимаются элементы строки.
+	* Так происходит для всех строк, выделенных данному процессу.
+
+4. Обработка локальных данных.
+	* После приёма всех строк процесс вычисляет максимальные элементы по каждой строке.
+	* Результаты затем собираются обратно у мастера (сбор не описан в этом фрагменте).
+
+## 4. Экспериментальная установка
+
+	* CPU: Intel Core i5-12500H
+	* 4 производительных ядра
+	* 8 энергоэффективных ядер
+	* RAM: 16 GB
+	* OS: Windows 11 Pro 24H2
+	* Компилятор: Intel C++ Compiler 2025
+	* Матрица: детерминированная, квадратная, 20000×20000
+	* Время — среднее по 8 повторениям.
+
+## 6. Результаты и обсуждение
+
+### 6.1 Корректность
+
+Функциональные тесты покрывают 97% кода, включая:
+	* матрицы разных размеров;
+	* строку длины 0;
+	* матрицу из одной строки;
+	* большие матрицы;
+	* соответствие MPI-версии последовательному алгоритму.
+
+Все тесты пройдены, расхождений нет.
+Корректность параллельной реализации подтверждена.
+
+### 6.2 Производительность
+
+Для оценки производительности измерялось чистое время выполнения алгоритма без учета создания тестовых данных. На основе полученных данных были рассчитаны метрики ускорения (Speedup) и эффективности (Efficiency).
+
+| Режим | Число процессов | Время, ms | Ускорение | Эффективность |
+| ----- | --------------- | --------- | --------- | ------------- |
+| seq   | 1               | 856       | 1.00      | —             |
+| mpi   | 1               | 945       | 0.91      | 91%           |
+| mpi   | 2               | 1222      | 0.70      | 35%           |
+| mpi   | 4               | 955       | 0.89      | 22%           |
+| mpi   | 8               | 717       | 1.19      | 14%           |
+| mpi   | 16              | 645       | 1.32      | 8%            |
+
+**Анализ результатов:**
+
+* На 1 процессе MPI хуже seq. Причиной этому послужили издержки, созданные MPI
+* На 2–4 процессах происходит замедление.
+Коммуникации занимают много времени
+* Ускорение появляется только при 8+ процессах, но эффективность падает.
+* 16 процессов дают ускорение всего 1.32×, что крайне мало для 16 логических ядер.
+* до 90% времени MPI-версии уходит на передачу данных,
+— полученный результат полностью подтверждает архитектурные проблемы реализации.
+* Реализация SEQ оптимальна и векторизована, поэтому конкурировать с ней сложно.
+## 8. Выводы
+
+*Последовательный алгоритм прост, эффективен, хорошо векторизуется и полностью memory-bound.
+
+* MPI-версия корректна, но неэффективна.
+* Master является узким местом;
+* объём вычислений на строку минимален и не окупает расходы на коммуникации.
+* На тестовой матрице 20000×20000 ускорение составляет лишь 1.32× при 16 процессах, что подтверждает низкое соотношение computation-to-communication.
+
+## 9. Источники
+
+1.  Parallel Programming Course - [https://learning-process.github.io/parallel_programming_course/ru/](https://learning-process.github.io/parallel_programming_course/ru/)
+2.  Parallel Programming 2025-2026 Video-Records - [https://disk.yandex.ru/d/NvHFyhOJCQU65w](https://disk.yandex.ru/d/NvHFyhOJCQU65w)
+3.  Open MPI: Documentation — [https://www.open-mpi.org/doc/](https://www.open-mpi.org/doc/)
+4.  C++ reference (cppreference.com) — [https://en.cppreference.com/w/cpp/algorithm/ranges/min_element](https://en.cppreference.com/w/cpp/algorithm/ranges/min_element)