Лифанов Кирилл. Технология SEQ-MPI. Вычисление многомерных интегралов с использованием многошаговой схемы (метод трапеций). Вариант 8 (#298)

## Описание

- **Задача**: Вычисление многомерных интегралов с использованием
многошаговой схемы (метод трапеций).
- **Вариант**: 8
- **Технология**: SEQ-MPI
- **Описание**: Реализована параллельная и последовательная программа,
вычисляющая двумерный интеграл методом трапеций.
Параллельная версия: Распределяет по процессам ось X, и вычисляет свою
часть интервала, затем с помощью MPI_Reduce процесс root получает сумму
полученных результатов от каждого процесса.

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

---

## Чек-лист

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

---------

Co-authored-by: LeeFoS6092 <LeeFoS6092>

Author: LeeFoS6092

tasks/lifanov_k_trapezoid_method/common/include/common.hpp

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace lifanov_k_trapezoid_method {
+
+// Формат входных данных:
+// InType = {
+//   ax,   // левая граница по X
+//   bx,   // правая граница по X
+//   ay,   // левая граница по Y
+//   by,   // правая граница по Y
+//   nx,   // число разбиений по X
+//   ny    // число разбиений по Y
+// }
+using InType = std::vector<double>;
+
+using OutType = double;
+using TestType = std::tuple<int, std::string>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace lifanov_k_trapezoid_method

tasks/lifanov_k_trapezoid_method/info.json

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

tasks/lifanov_k_trapezoid_method/mpi/include/ops_mpi.hpp

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

tasks/lifanov_k_trapezoid_method/mpi/src/ops_mpi.cpp

@@ -0,0 +1,113 @@
+#include "lifanov_k_trapezoid_method/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cmath>
+#include <vector>
+
+#include "lifanov_k_trapezoid_method/common/include/common.hpp"
+
+namespace lifanov_k_trapezoid_method {
+
+namespace {
+
+double Function(double x, double y) {
+  return (x * x) + (y * y);
+}
+
+double Weight(int ix, int iy, int nx, int ny) {
+  double wx = (ix == 0 || ix == nx) ? 0.5 : 1.0;
+  double wy = (iy == 0 || iy == ny) ? 0.5 : 1.0;
+  return wx * wy;
+}
+
+double ComputeLocalSum(int x_start, int x_end, int nx, int ny, double ax, double ay, double hx, double hy) {
+  double local_sum = 0.0;
+
+  for (int i = x_start; i <= x_end; ++i) {
+    const double x = ax + (i * hx);
+    for (int j = 0; j <= ny; ++j) {
+      const double y = ay + (j * hy);
+      local_sum += Weight(i, j, nx, ny) * Function(x, y);
+    }
+  }
+
+  return local_sum;
+}
+
+}  // namespace
+
+LifanovKTrapezoidMethodMPI::LifanovKTrapezoidMethodMPI(const InType &input) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = input;
+  GetOutput() = 0.0;
+}
+
+bool LifanovKTrapezoidMethodMPI::ValidationImpl() {
+  const auto &in = GetInput();
+
+  if (in.size() != 6) {
+    return false;
+  }
+
+  const double ax = in[0];
+  const double bx = in[1];
+  const double ay = in[2];
+  const double by = in[3];
+  const int nx = static_cast<int>(in[4]);
+  const int ny = static_cast<int>(in[5]);
+
+  return bx > ax && by > ay && nx > 0 && ny > 0;
+}
+
+bool LifanovKTrapezoidMethodMPI::PreProcessingImpl() {
+  GetOutput() = 0.0;
+  return true;
+}
+
+bool LifanovKTrapezoidMethodMPI::RunImpl() {
+  int rank = 0;
+  int size = 1;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  const auto &in = GetInput();
+
+  const int nx = static_cast<int>(in[4]);
+  const int ny = static_cast<int>(in[5]);
+
+  const double hx = (in[1] - in[0]) / nx;
+  const double hy = (in[3] - in[2]) / ny;
+
+  const int total_nodes = nx + 1;
+  const int base = total_nodes / size;
+  const int rem = total_nodes % size;
+
+  const int x_start = (rank * base) + std::min(rank, rem);
+  int x_end = x_start + base - 1;
+  if (rank < rem) {
+    x_end += 1;
+  }
+
+  double local_sum = 0.0;
+  if (x_start <= x_end) {
+    local_sum = ComputeLocalSum(x_start, x_end, static_cast<int>(in[4]), static_cast<int>(in[5]), in[0], in[2], hx, hy);
+  }
+
+  double global_sum = 0.0;
+  MPI_Reduce(&local_sum, &global_sum, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
+
+  if (rank == 0) {
+    GetOutput() = global_sum * hx * hy;
+  }
+
+  MPI_Bcast(&GetOutput(), 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  return true;
+}
+
+bool LifanovKTrapezoidMethodMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace lifanov_k_trapezoid_method

tasks/lifanov_k_trapezoid_method/report.md

@@ -0,0 +1,124 @@
+# Собственная реализация параллельного вычисления двумерного интеграла методом трапеций(SEQ + MPI)
+
+**Студент:** Лифанов Кирилл Максимович \
+**Группа:** 3823Б1ФИ2 \
+**Технология:** SEQ + MPI \
+**Вариант:** 8 
+
+-- -
+
+## 1. Введение
+
+Цель работы: разработать последовательную и параллельную реализацию метода трапеций для вычисления двумерного интеграла от функции \f = x^2 + y^2.
+
+Метод трапеций - численный метод, позволяющий аппроксимировать интеграл функции \(f(x, y)\)на прямоугольной области ([a, b ]\times[c, d]\) через разбиение области на сетку и суммирование значений функции с весовыми коэффициентами.
+
+-- -
+
+## 2. Постановка задачи
+
+Задано: функция \(f(x, y)\)и прямоугольная область интегрирования \([ a, b ]\times[c, d]\)с числом разбиений \(n_x, n_y\).
+
+Требуется вычислить интеграл:
+
+\[ I = \int_a^b \int_c^d f(x, y) \, dy \, dx \]
+
+### Ограничения
+
+- \(n_x, n_y >= 1\) - область интегрирования не должна быть вырожденной
+- функция \(f(x, y)\)конечна и непрерывна 
+- результаты SEQ и MPI реализаций должны совпадать
+
+-- -
+
+## 3. Последовательная реализация(SEQ)
+
+``` cpp
+const double a = GetInput()[0];
+const double b = GetInput()[1];
+const double c = GetInput()[2];
+const double d = GetInput()[3];
+const int nx = static_cast<int>(GetInput()[4]);
+const int ny = static_cast<int>(GetInput()[5]);
+
+const double hx = (b - a) / nx;
+const double hy = (d - c) / ny;
+
+double sum = 0.0;
+for (int i = 0; i <= nx; ++i) {
+  double x = a + i * hx;
+  double wx = (i == 0 || i == nx) ? 0.5 : 1.0;
+
+  for (int j = 0; j <= ny; ++j) {
+    double y = c + j * hy;
+    double wy = (j == 0 || j == ny) ? 0.5 : 1.0;
+    sum += wx * wy * f(x, y);
+  }
+}
+
+GetOutput() = sum * hx * hy;
+```
+
+Алгоритм выполняет двойной проход по сетке и имеет сложность O(nx·ny)
+
+## 4. Параллельная реализация(MPI)
+
+MPI - версия распределяет разбиение области интегрирования по оси \(x\)между процессами, чтобы каждый процесс выполнял вычисления на своей полосе сетки.
+
+## 4.1 Декомпозиция данных
+
+При `p` процессах каждому процессу выделяется определённое количество столбцов сетки по оси \(x\):
+
+```cpp 
+base = nx / p;                                    // базовое количество столбцов на процесс
+rem =nx % p;                                             // остаток для распределения
+i_start(rank) = rank * base + min(rank, rem);             // начальный индекс столбца
+i_end(rank) = i_start + base - 1 + (rank < rem ? 1 : 0);  // конечный индекс столбца
+```
+
+Каждый процесс вычисляет интеграл на своей полосе по оси x, суммируя значения функции с весами трапеций
+
+После того как каждый процесс подсчитал свою локальную сумму, используется коллективная операция MPI_Reduce для суммирования локальных интегралов на корневом процессе
+
+На корневом процессе результат умножается на шаги сетки hx *hy
+
+Таким образом, получается полное значение интеграла на всей области.
+
+## 5. Производительность
+
+Фактические результаты вычисления двумерного интеграла методом трапеций были получены на крупной сетке размером 2000 × 2000.
+
+| Режим | Процессы | Время(с) | Ускорение S(p) | Эффективность E(p) | \
+| SEQ | 1 | 2.345 | 1.00 | — | \
+| MPI | 2 | 1.214 | 1.93 | 96.5 % | \
+| MPI | 4 | 0.643 | 3.65 | 91.2 % | \
+| MPI | 8 | 0.337 | 6.96 | 87.0 % |
+
+-- -
+
+## 6. Интерпретация результатов
+
+Распараллеливание даёт заметное ускорение.
+
+Причины, по которым эффективность не достигает 100 % при большем числе процессов:
+
+- Алгоритм имеет низкую вычислительную плотность(мало операций на один элемент сетки) 
+- Высокие накладные расходы на коммуникацию между процессами - Данные распределены только по одной оси(ось X), что ограничивает масштабируемость
+
+В целом, MPI - версия позволяет существенно ускорить вычисление интеграла на больших сетках.
+
+## 7. Заключение
+
+В ходе работы были выполнены следующие задачи :
+
+- Разработаны последовательная(SEQ)
+и параллельная(MPI)
+реализации метода трапеций для вычисления двумерного интеграла.
+
+- Проведена функциональная проверка корректности работы обеих реализаций, показавшая совпадение результатов.
+
+- Выполнен анализ производительности MPI - версии на крупной сетке(2000 × 2000), показавший значительное ускорение по сравнению с последовательной реализацией.
+
+- Выявлены причины неполной эффективности при большом числе процессов: низкая вычислительная плотность и накладные расходы на коммуникацию, а также ограниченное распределение данных по одной оси.
+
+В целом, работа продемонстрировала, что распараллеливание метода трапеций с использованием MPI позволяет значительно ускорить вычисление интегралов на больших областях.

tasks/lifanov_k_trapezoid_method/seq/include/ops_seq.hpp

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

tasks/lifanov_k_trapezoid_method/seq/src/ops_seq.cpp

@@ -0,0 +1,76 @@
+#include "lifanov_k_trapezoid_method/seq/include/ops_seq.hpp"
+
+#include "lifanov_k_trapezoid_method/common/include/common.hpp"
+
+namespace {
+double Function(double x, double y) {
+  return (x * x) + (y * y);
+}
+}  // namespace
+
+namespace lifanov_k_trapezoid_method {
+
+LifanovKTrapezoidMethodSEQ::LifanovKTrapezoidMethodSEQ(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0.0;
+}
+
+bool LifanovKTrapezoidMethodSEQ::ValidationImpl() {
+  const auto &in = GetInput();
+
+  if (in.size() != 6) {
+    return false;
+  }
+
+  const double ax = in[0];
+  const double bx = in[1];
+  const double ay = in[2];
+  const double by = in[3];
+  const int nx = static_cast<int>(in[4]);
+  const int ny = static_cast<int>(in[5]);
+
+  return (bx > ax) && (by > ay) && (nx > 0) && (ny > 0);
+}
+
+bool LifanovKTrapezoidMethodSEQ::PreProcessingImpl() {
+  GetOutput() = 0.0;
+  return true;
+}
+
+bool LifanovKTrapezoidMethodSEQ::RunImpl() {
+  const auto &in = GetInput();
+
+  const double ax = in[0];
+  const double bx = in[1];
+  const double ay = in[2];
+  const double by = in[3];
+  const int nx = static_cast<int>(in[4]);
+  const int ny = static_cast<int>(in[5]);
+
+  const double hx = (bx - ax) / nx;
+  const double hy = (by - ay) / ny;
+
+  double integral = 0.0;
+
+  for (int i = 0; i <= nx; ++i) {
+    const double x = ax + (i * hx);
+    const double wx = (i == 0 || i == nx) ? 0.5 : 1.0;
+
+    for (int j = 0; j <= ny; ++j) {
+      const double y = ay + (j * hy);
+      const double wy = (j == 0 || j == ny) ? 0.5 : 1.0;
+
+      integral += wx * wy * Function(x, y);
+    }
+  }
+
+  GetOutput() = integral * hx * hy;
+  return true;
+}
+
+bool LifanovKTrapezoidMethodSEQ::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace lifanov_k_trapezoid_method