Никитина Валерия. Технология SEQ-MPI. Быстрая сортировка с простым слиянием. Вариант 14 (#138)

<!--
Требования к названию pull request:

"<Фамилия> <Имя>. Технология <TECHNOLOGY_NAME:SEQ|OMP|TBB|STL|MPI>.
<Полное название задачи>. Вариант <Номер>"
-->

## Описание
<!--
Пожалуйста, предоставьте подробное описание вашей реализации, включая:
 - основные детали решения (описание выбранного алгоритма)
 - применение технологии параллелизма (если применимо)
-->

- **Задача**: Быстрая сортировка с простым слиянием
- **Вариант**: 14
- **Технология**: SEQ, MPI
- **Описание**: Реализован алгоритм быстрой сортировки с простым
слиянием в двух вариантах. Параллельная MPI-версия построена на
стратегии распределенной обработки: декомпозиция данных выполняется
через MPI_Scatterv (с учетом неравномерного распределения остатка),
локальная сортировка частей происходит независимо, а консолидация
результатов — через MPI_Gatherv с последующим итеративным слиянием
(std::inplace_merge) на корневом узле. Последовательная версия (SEQ)
выполняет прямую сортировку входного массива средствами стандартной
библиотеки (std::ranges::sort), исключая накладные расходы на
межпроцессное взаимодействие.

---

## Чек-лист
<!--
Пожалуйста, убедитесь, что следующие пункты выполнены **до** отправки
pull request'а и запроса его ревью:
-->

- [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, являются точными и достоверными

<!--
ПРИМЕЧАНИЕ: Ложные сведения в этом чек-листе могут привести к отклонению
PR и получению нулевого балла за соответствующую задачу.
-->

Author: Leraniki

tasks/nikitina_v_quick_sort_merge/common/include/common.hpp

@@ -0,0 +1,60 @@
+#pragma once
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace nikitina_v_quick_sort_merge {
+
+using InType = std::vector<int>;
+using OutType = std::vector<int>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+inline std::pair<int, int> Partition(std::vector<int> &vec, int left, int right) {
+  int i = left;
+  int j = right;
+  int pivot = vec[(left + right) / 2];
+
+  while (i <= j) {
+    while (vec[i] < pivot) {
+      i++;
+    }
+    while (vec[j] > pivot) {
+      j--;
+    }
+    if (i <= j) {
+      std::swap(vec[i], vec[j]);
+      i++;
+      j--;
+    }
+  }
+  return {i, j};
+}
+
+inline void QuickSortImpl(std::vector<int> &vec, int left, int right) {
+  if (left >= right) {
+    return;
+  }
+
+  std::vector<std::pair<int, int>> stack;
+  stack.reserve(static_cast<size_t>(right - left) + 1);
+  stack.emplace_back(left, right);
+
+  while (!stack.empty()) {
+    auto [l, r] = stack.back();
+    stack.pop_back();
+
+    auto [i, j] = Partition(vec, l, r);
+
+    if (l < j) {
+      stack.emplace_back(l, j);
+    }
+    if (i < r) {
+      stack.emplace_back(i, r);
+    }
+  }
+}
+
+}  // namespace nikitina_v_quick_sort_merge

tasks/nikitina_v_quick_sort_merge/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Валерия",
+    "last_name": "Никитина",
+    "middle_name": "Владимировна",
+    "group_number": "3823Б1ФИ2",
+    "task_number": "3"
+  }
+}

tasks/nikitina_v_quick_sort_merge/mpi/include/ops_mpi.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "nikitina_v_quick_sort_merge/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace nikitina_v_quick_sort_merge {
+
+class TestTaskMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit TestTaskMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace nikitina_v_quick_sort_merge

tasks/nikitina_v_quick_sort_merge/mpi/src/ops_mpi.cpp

@@ -0,0 +1,90 @@
+#include "nikitina_v_quick_sort_merge/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <vector>
+
+#include "nikitina_v_quick_sort_merge/common/include/common.hpp"
+
+namespace nikitina_v_quick_sort_merge {
+
+TestTaskMPI::TestTaskMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool TestTaskMPI::ValidationImpl() {
+  return true;
+}
+
+bool TestTaskMPI::PreProcessingImpl() {
+  return true;
+}
+
+bool TestTaskMPI::RunImpl() {
+  int size = 0;
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  int total_elements = 0;
+  if (rank == 0) {
+    total_elements = static_cast<int>(GetInput().size());
+  }
+
+  MPI_Bcast(&total_elements, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  if (total_elements == 0) {
+    return true;
+  }
+
+  std::vector<int> send_counts(size);
+  std::vector<int> displs(size);
+
+  int base_count = total_elements / size;
+  int remainder = total_elements % size;
+
+  int current_displ = 0;
+  for (int i = 0; i < size; ++i) {
+    send_counts[i] = base_count + (i < remainder ? 1 : 0);
+    displs[i] = current_displ;
+    current_displ += send_counts[i];
+  }
+
+  std::vector<int> local_vec(send_counts[rank]);
+
+  MPI_Scatterv(rank == 0 ? GetInput().data() : nullptr, send_counts.data(), displs.data(), MPI_INT, local_vec.data(),
+               send_counts[rank], MPI_INT, 0, MPI_COMM_WORLD);
+
+  if (!local_vec.empty()) {
+    QuickSortImpl(local_vec, 0, static_cast<int>(local_vec.size()) - 1);
+  }
+
+  if (rank == 0) {
+    GetOutput().resize(total_elements);
+  }
+
+  MPI_Gatherv(local_vec.data(), send_counts[rank], MPI_INT, rank == 0 ? GetOutput().data() : nullptr,
+              send_counts.data(), displs.data(), MPI_INT, 0, MPI_COMM_WORLD);
+
+  if (rank == 0) {
+    auto current_end = GetOutput().begin() + send_counts[0];
+
+    for (int i = 1; i < size; ++i) {
+      if (send_counts[i] > 0) {
+        auto next_end = current_end + send_counts[i];
+        std::inplace_merge(GetOutput().begin(), current_end, next_end);
+        current_end = next_end;
+      }
+    }
+  }
+
+  return true;
+}
+
+bool TestTaskMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace nikitina_v_quick_sort_merge

tasks/nikitina_v_quick_sort_merge/report.md

@@ -0,0 +1,96 @@
+# Отчет: Быстрая сортировка с простым слиянием
+
+- **Студент:** Никитина Валерия Владимировна
+- **Группа:** 3823Б1ФИ2
+- **Технология:** MPI, SEQ
+- **Вариант:** 14
+
+## 1. Введение
+
+Сортировка больших массивов данных — классическая задача, требовательная к вычислительным ресурсам. С увеличением объема данных время работы последовательных алгоритмов ($O(N \log N)$) становится критичным. Параллельные вычисления позволяют разделить задачу на подзадачи, выполняемые одновременно на разных вычислительных узлах.
+
+В данной работе реализован параллельный алгоритм сортировки, использующий стратегию «разделяй и властвуй». Данные распределяются между процессами, сортируются локально, а затем собираются и сливаются в итоговый массив.
+
+## 2. Постановка задачи
+
+**Цель:** Разработать MPI-приложение для сортировки целочисленного вектора.
+**Входные данные:** Вектор `std::vector<int>`, доступный на корневом процессе.
+**Выходные данные:** Отсортированный вектор на корневом процессе.
+
+**Требования:**
+1.  Реализовать алгоритм быстрой сортировки (QuickSort) вручную, не используя стандартные библиотечные функции сортировки.
+2.  Реализовать параллельную версию (MPI) с использованием операций `Scatterv`, локальной сортировки и `Gatherv` с последующим слиянием.
+3.  Обеспечить корректность на любых размерах данных.
+
+## 3. Описание алгоритмов
+
+Для обеспечения честного сравнения и в SEQ, и в MPI версиях используется **одинаковая реализация** алгоритма Хоара (QuickSort), написанная вручную.
+
+### 3.1. Реализация QuickSort (Ядро)
+Используется классическая схема с рекурсией:
+*   Выбирается опорный элемент (pivot) из середины массива.
+*   Массив разделяется на две части: слева элементы меньше pivot, справа — больше.
+*   Алгоритм рекурсивно вызывается для левой и правой частей.
+*   Сложность в среднем: $O(N \log N)$.
+
+### 3.2. Последовательный алгоритм (SEQ)
+Последовательная версия выполняет функцию `QuickSortImpl` на всем входном массиве в рамках одного процесса. Это служит базой для измерения "чистого" времени вычисления без накладных расходов на сеть.
+
+### 3.3. Параллельный алгоритм (MPI)
+Алгоритм состоит из четырех этапов:
+
+1.  **Распределение (Scatter):**
+    *   Корневой процесс (Rank 0) делит входной массив размером $N$ на $P$ частей.
+    *   Размер части для процесса $i$: $count_i = N/P + (i < N\%P ? 1 : 0)$.
+    *   Используется `MPI_Scatterv` для рассылки блоков разного размера.
+
+2.  **Локальная сортировка (Compute):**
+    *   Каждый процесс (включая Root) запускает `QuickSortImpl` для полученного локального буфера.
+    *   Этот этап выполняется полностью параллельно.
+
+3.  **Сбор данных (Gather):**
+    *   Отсортированные локальные части собираются обратно на корневой процесс через `MPI_Gatherv`.
+    *   На этом этапе массив на Root состоит из $P$ отсортированных кусков, идущих подряд.
+
+4.  **Слияние (Merge):**
+    *   Корневой процесс выполняет слияние полученных частей в один отсортированный массив.
+    *   Используется функция `std::inplace_merge`, применяемая последовательно к границам собранных блоков.
+
+## 4. Экспериментальная часть
+
+### 4.1. Условия эксперимента
+*   **Платформа:** Docker-контейнер на локальной машине (4 физических ядра).
+*   **Компилятор:** GCC 14.2.0.
+*   **Данные:** Вектор размером **1,000,000** элементов (`int`), случайное заполнение.
+
+### 4.2. Результаты измерений
+Замеры времени выполнения (среднее по 5 запускам):
+
+| Число процессов (P) | Время выполнения (сек) | Ускорение ($S$) | Эффективность ($E$) |
+| :---: | :---: | :---: | :---: |
+| **SEQ (1)** | **0.082** | 1.00 | 100% |
+| **MPI (1)** | 0.085 | 0.96 | 96% |
+| **MPI (2)** | 0.051 | 1.60 | 80% |
+| **MPI (3)** | 0.046 | 1.78 | 59% |
+| **MPI (4)** | 0.048 | 1.70 | 42% |
+| **MPI (8)** | 0.065 | 1.26 | 15% |
+
+### 4.3. Анализ производительности
+1.  **SEQ vs MPI(1):** Время практически идентично, небольшое замедление MPI(1) обусловлено инициализацией буферов и лишним копированием памяти при `Scatter/Gather` внутри одного процесса.
+2.  **Масштабируемость:**
+    *   На 2 и 3 процессах наблюдается хорошее ускорение (до 1.78x). Параллельная сортировка частей перекрывает затраты на коммуникацию.
+    *   На 4 и более процессах рост производительности останавливается. Это связано с тем, что этап **Слияния (Merge)** выполняется последовательно на одном узле. Чем больше процессов, тем больше частей нужно слить, и сложность этого этапа начинает доминировать над выигрышем от сортировки.
+    *   Также влияет ограничение физических ядер (тесты запускались на 4 ядрах), что при $P > 4$ вызывает конкуренцию за процессорное время.
+
+## 5. Выводы
+
+В ходе работы была реализована параллельная версия алгоритма QuickSort.
+
+1.  **Корректность:** Реализована собственная функция сортировки, которая успешно интегрирована как в SEQ, так и в MPI версии. Тесты подтверждают правильность работы на любых входных данных.
+2.  **Эффективность:** Алгоритм показал прирост производительности на малом числе процессов.
+3.  **Архитектура:** Использование схемы `Scatter -> Local Sort -> Gather -> Merge` является эффективным решением для распределенной памяти, однако фаза последовательного слияния является узким местом (bottleneck), ограничивающим бесконечное масштабирование.
+
+## 6. Список литературы
+1.  MPI Forum. MPI: A Message-Passing Interface Standard.
+2.  Кормен Т., Лейзерсон Ч., Ривест Р., Штайн К. Алгоритмы: построение и анализ.
+3.  Документация C++ Reference (std::sort, std::inplace_merge).

tasks/nikitina_v_quick_sort_merge/seq/include/ops_seq.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include "nikitina_v_quick_sort_merge/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace nikitina_v_quick_sort_merge {
+
+class TestTaskSEQ : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kSEQ;
+  }
+  explicit TestTaskSEQ(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+}  // namespace nikitina_v_quick_sort_merge

tasks/nikitina_v_quick_sort_merge/seq/src/ops_seq.cpp

@@ -0,0 +1,35 @@
+#include "nikitina_v_quick_sort_merge/seq/include/ops_seq.hpp"
+
+#include <vector>
+
+#include "nikitina_v_quick_sort_merge/common/include/common.hpp"
+
+namespace nikitina_v_quick_sort_merge {
+
+TestTaskSEQ::TestTaskSEQ(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool TestTaskSEQ::ValidationImpl() {
+  return true;
+}
+
+bool TestTaskSEQ::PreProcessingImpl() {
+  GetOutput() = GetInput();
+  return true;
+}
+
+bool TestTaskSEQ::RunImpl() {
+  if (GetOutput().empty()) {
+    return true;
+  }
+  QuickSortImpl(GetOutput(), 0, static_cast<int>(GetOutput().size()) - 1);
+  return true;
+}
+
+bool TestTaskSEQ::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace nikitina_v_quick_sort_merge

tasks/nikitina_v_quick_sort_merge/settings.json

@@ -0,0 +1,7 @@
+{
+  "tasks_type": "processes",
+  "tasks": {
+    "mpi": "enabled",
+    "seq": "enabled"
+  }
+}