Дорофеев Иван. Технология SEQ-MPI. Интегрирование – метод Монте-Карло. Вариант 21. (#65)

## Описание
**SEQ:** Последовательный алгоритм основан на статистической оценке
определённого интеграла по набору случайных точек. Сначала определяется
область интегрирования и количество выборок. Затем генерируются
случайные точки, равномерно распределённые внутри данной области, на
каждой точке вычисляется значение функции, после чего среднее значение
умножается на объём области, что и даёт приближённый результат
интегрирования.

**MPI:** В параллельной версии общее количество выборок делится между
всеми процессами. Каждый процесс генерирует свой набор случайных точек и
вычисляет промежуточную сумму значений функции. Для этого общее число
выборок разбивается на число блоков, равное числу процессов. Размеры
блоков одинаковы, за исключением последнего процесса, которому
выделяются остаточные выборки. После выполнения локальных вычислений
результаты всех процессов суммируются с помощью операции MPI_Reduce, и
итоговый результат собирается на нулевом процессе.

Отчёт содержит описание системы, на которой проводились эксперименты,
результаты и вывод.

---

## Чек-лист
<!--
Пожалуйста, убедитесь, что следующие пункты выполнены **до** отправки
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 и получению нулевого балла за соответствующую задачу.
-->

---------

Co-authored-by: 4elodoy-Molovek <ivandor22@outlook.com>

Author: 4elodoy-Molovek

tasks/dorofeev_i_monte_carlo_integration/common/include/common.hpp

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <functional>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace dorofeev_i_monte_carlo_integration_processes {
+
+struct InputData {
+  std::function<double(const std::vector<double> &)> func;  // f(x)
+  std::vector<double> a;                                    // lower bounds
+  std::vector<double> b;                                    // upper bounds
+  int samples = 0;                                          // number of samples
+};
+
+using InType = InputData;
+using OutType = double;
+
+using TestType = std::tuple<int, std::string>;  // for testing purposes
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace dorofeev_i_monte_carlo_integration_processes

tasks/dorofeev_i_monte_carlo_integration/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Дорофеев",
+    "last_name": "Иван",
+    "middle_name": "Денисович",
+    "group_number": "3823Б1ФИ1",
+    "task_number": "1"
+  }
+}

tasks/dorofeev_i_monte_carlo_integration/mpi/include/ops_mpi.hpp

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

tasks/dorofeev_i_monte_carlo_integration/mpi/src/ops_mpi.cpp

@@ -0,0 +1,138 @@
+#include "dorofeev_i_monte_carlo_integration/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <random>
+#include <ranges>
+#include <utility>
+#include <vector>
+
+#include "dorofeev_i_monte_carlo_integration/common/include/common.hpp"
+
+namespace dorofeev_i_monte_carlo_integration_processes {
+
+DorofeevIMonteCarloIntegrationMPI::DorofeevIMonteCarloIntegrationMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool DorofeevIMonteCarloIntegrationMPI::ValidationImpl() {
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+
+  bool valid = true;
+
+  if (rank == 0) {
+    const auto &in = GetInput();
+    valid =
+        in.func && !in.a.empty() && in.a.size() == in.b.size() &&
+        std::ranges::all_of(std::views::iota(size_t{0}, in.a.size()), [&](size_t i) { return in.b[i] > in.a[i]; }) &&
+        in.samples > 0;
+  }
+
+  MPI_Bcast(&valid, 1, MPI_C_BOOL, 0, MPI_COMM_WORLD);
+  return valid;
+}
+
+bool DorofeevIMonteCarloIntegrationMPI::PreProcessingImpl() {
+  GetOutput() = 0.0;
+  return true;
+}
+
+bool DorofeevIMonteCarloIntegrationMPI::RunImpl() {
+  int rank = 0;
+  int size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  // BROADCAST INPUT
+  InType in;
+
+  if (rank == 0) {
+    in = GetInput();
+  }
+
+  // BROADCAST DIMS
+  int dims = static_cast<int>(rank == 0 ? in.a.size() : 0);
+  MPI_Bcast(&dims, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  // resize on other ranks
+  if (rank != 0) {
+    in.a.resize(dims);
+    in.b.resize(dims);
+  }
+
+  // BROADCAST BOUNDS
+  MPI_Bcast(in.a.data(), dims, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  MPI_Bcast(in.b.data(), dims, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+
+  // BROADCAST SAMPLES
+  MPI_Bcast(&in.samples, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  // BROADCAST FUNC ID
+  int func_id = (rank == 0 ? 1 : 0);
+  MPI_Bcast(&func_id, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  // restore the function
+  switch (func_id) {
+    case 1:
+      in.func = [](const std::vector<double> &x) { return x[0] * x[0]; };
+      break;
+    default:
+      in.func = nullptr;
+  }
+
+  // CALCULATIONS
+  int n_total = in.samples;
+  int n_local = n_total / size;
+  if (rank == size - 1) {
+    n_local += n_total % size;
+  }
+
+  std::vector<std::uniform_real_distribution<double>> dist;
+  dist.reserve(dims);
+  for (int dim = 0; std::cmp_less(dim, dims); dim++) {
+    dist.emplace_back(in.a[dim], in.b[dim]);
+  }
+
+  std::mt19937 gen(rank + 777);
+  double local_sum = 0.0;
+
+  std::vector<double> x;
+  x.assign(static_cast<size_t>(dims), 0.0);
+
+  for (int i = 0; i < n_local; ++i) {
+    for (int dim = 0; std::cmp_less(dim, dims); dim++) {
+      x[static_cast<size_t>(dim)] = dist[dim](gen);
+    }
+    local_sum += in.func(x);
+  }
+
+  // REDUCE
+  double global_sum = 0.0;
+  MPI_Reduce(&local_sum, &global_sum, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
+
+  // RESULT
+  double result = 0.0;
+  if (rank == 0) {
+    double volume = 1.0;
+    for (int dim = 0; std::cmp_less(dim, dims); dim++) {
+      volume *= (in.b[dim] - in.a[dim]);
+    }
+    result = (global_sum / n_total) * volume;
+  }
+
+  MPI_Bcast(&result, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+
+  GetOutput() = result;
+  return true;
+}
+
+bool DorofeevIMonteCarloIntegrationMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace dorofeev_i_monte_carlo_integration_processes

tasks/dorofeev_i_monte_carlo_integration/report.md

@@ -0,0 +1,158 @@
+# Интегрирование – метод Монте-Карло
+
+**Student:** Дорофеев Иван Денисович, group 3823Б1ФИ1  
+**Technology:** SEQ | MPI  
+**Variant:** 21
+
+---
+
+## 1. Introduction
+
+Метод Монте-Карло — один из универсальных способов численного интегрирования, позволяющий эффективно оценивать интегралы любой размерности. Однако точность метода и время работы напрямую зависят от количества случайных выборок (samples). Увеличение количества выборок повышает точность, но также увеличивает время выполнения, что делает задачу подходящей для распараллеливания. 
+
+Ожидается, что MPI-версия позволит уменьшить время выполнения за счёт распределения выборок между процессами.
+
+---
+
+## 2. Problem statement
+
+Требуется вычислить значение определённого интеграла методом Монте-Карло.
+
+### Входные данные:
+
+- Границы интегрирования:  
+  $a = 0,\quad b = 1$
+
+- Количество выборок: 190000
+
+- Функция:  
+  $f(x) = x^2$
+
+### Выходные данные:
+
+- Одно действительное число — приближённое значение интеграла.
+
+---
+
+## 3. Baseline Algorithm (Sequential)
+
+1. Сгенерировать N равномерных случайных точек из интервала $[a, b]$.
+
+2. Вычислить значение функции в каждой точке.
+
+3. Найти среднее всех вычисленных значений.
+
+4. Умножить среднее на длину интервала $(b-a)$.
+
+Последовательная реализация проста, но требует выполнения всех N вычислений в одном процессе.
+
+---
+
+## 4. Parallelization Scheme (MPI)
+
+Для распараллеливания используется идея независимости выборок:  
+каждый процесс может самостоятельно выполнить часть выборок и затем отправить свой частичный результат.
+
+### Схема:
+
+1. Корневой процесс рассылает параметры задачи всем участникам.
+
+2. Каждый процесс:
+   
+   - выполняет часть выборок:   
+     $N_p = \frac{N}{P} $
+   
+   - рассчитывает среднее значение функции на своём подмножестве.
+
+3. Результаты всех процессов объединяются с помощью **MPI_Reduce**.
+
+4. Корневой процесс вычисляет итоговый интеграл.
+
+Поскольку метод Монте-Карло "естественно" распараллеливается, эффективность MPI в идеальных условиях может быть высокой.
+
+---
+
+## 5. Experimental Setup
+
+- Hardware/OS:
+  - CPU: 13th Gen Intel i5-13420H (12) @ 4.6GHz, 8 ядер
+  - RAM: 16GB RAM
+  - OS: Ubuntu 25.10 x86_64
+  - Среда выполнения: Docker (Ubuntu trixie/sid (noble) x86_64)
+- Toolchain: compiler, version, build type (Release/RelWithDebInfo)
+  - CMake 3.28.3
+  - g++ 13.3.0
+  - OpenMPI
+  - Сборка: Release
+- Data:
+  - Количество выборок: 190000
+  - Функция: $f(x)=x^2$
+  - Тесты производительности запускались для **SEQ**, **MPI: 2**, **MPI: 4** процессов.
+
+---
+
+## 6. Results and Discussion
+
+### 6.1 Correctness
+
+Корректность проверена тестами GoogleTest.  
+Точное значение интеграла:
+
+$\int_0^1 x^2 dx = \frac{1}{3} \approx 0.333333 $
+
+
+Все варианты укладываются в допуск ±0.05.
+
+---
+
+## 6.2 Performance
+
+| Mode    | Processes | Time (s)     | Speedup  | Efficiency |
+| ------- | --------- | ------------ | -------- | ---------- |
+| **seq** | 1         | **0.002277** | **1.00** | —          |
+| **mpi** | 2         | **0.001751** | **1.30** | **65%**    |
+| **mpi** | 4         | **0.001137** | **2.00** | **50%**    |
+
+---
+
+## 7. Discussion
+
+Результаты экспериментов показывают, что MPI-версия действительно работает быстрее последовательной SEQ-реализации при одинаковом количестве выборок.
+
+Для 2 процессов ускорение составляет **1.30×** при эффективности **65%**.  
+Для 4 процессов ускорение достигает **2.00×**, что соответствует эффективности **50%**.
+
+Эффективность снижается с ростом числа процессов, это ожидаемое поведение для MPI, так как накладные расходы растут, а объём работы, приходящийся на каждый процесс, уменьшается.
+
+Основные источники потерь производительности:
+
+- необходимость синхронизации между процессами,
+
+- выполнение коллективных операций (например, **MPI_Allreduce**),
+
+- накладные расходы MPI, усиливающиеся при запуске внутри Docker-контейнера,
+
+- относительно малый объём вычислений на один процесс при 4-процессном запуске.
+
+Тем не менее ускорение остаётся значительным — даже с учётом накладных расходов распараллеливание уменьшает общее время расчёта примерно вдвое.
+
+---
+
+## 8. Conclusions
+
+Метод Монте-Карло хорошо поддаётся параллелизации, и MPI-версия показывает ощутимое ускорение.
+
+Хотя эффективность не достигает 100% из-за накладных расходов, ускорение в 2 раза при использовании 4 процессов подтверждает преимущества распараллеливания.
+
+MPI-подход особенно полезен при значительно больших объёмах выборок, где накладные расходы становятся менее заметными.
+
+---
+
+## 9. References
+
+1. "Параллельное программирование для кластерных систем" ИИТММ, ННГУ им. Лобачевского
+2. [Open MPI Documentation](https://www.open-mpi.org/doc/)
+3. [MPI Reference - Message Passing Interface | Microsoft Learn](https://learn.microsoft.com/en-us/message-passing-interface/mpi-reference)
+4. [MPI: A Message-Passing Interface Standard](https://www.mpi-forum.org/docs/mpi-5.0/mpi50-report.pdf)
+
+

tasks/dorofeev_i_monte_carlo_integration/seq/include/ops_seq.hpp

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