Еремин Василий. Технология SEQ-MPI. Алгоритм глобального поиска (Стронгина) для одномерных задач оптимизации. Распараллеливание по характеристикам. Вариант 11 (#282)

## Описание
- **Задача**: Алгоритм глобального поиска (Стронгина) для одномерных
задач оптимизации. Распараллеливание по характеристикам.
- **Вариант**: 11
- **Технология**: SEQ, MPI
- **Описание** вашей реализации и отчёта.  
**Реализация:** Реализован алгоритм Стронгина для поиска глобального
минимума. Последовательная версия итерационно уточняет оценку константы
Липшица и выбирает новые точки на основе характеристик интервалов. В
параллельной версии на базе MPI вычисление наклонов и характеристик
распределено между процессами по циклической схеме (stride-подход), что
обеспечивает балансировку нагрузки при росте числа точек.
  
    **Ключевые MPI операции:**
- **`MPI_Bcast`** — рассылка параметров поиска и координат каждой новой
точки испытания.
- **`MPI_Allreduce` (MAX)** — нахождение глобальной оценки константы
Липшица $M$.
- **`MPI_Allreduce` (MAXLOC)** — выбор интервала с максимальной
характеристикой (возвращает значение и индекс процесса).
  
  **Отчёт:**
Содержит описание модели Стронгина, схему распараллеливания
характеристик, результаты верификации на тестовых функциях и анализ
ускорения (Speedup/Efficiency) MPI-версии.
---

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

Author: ErVasyaVC

tasks/eremin_v_strongin_algorithm/common/include/common.hpp

@@ -0,0 +1,15 @@
+#pragma once
+
+#include <functional>
+#include <tuple>
+
+#include "task/include/task.hpp"
+
+namespace eremin_v_strongin_algorithm {
+
+using InType = std::tuple<double, double, double, int, std::function<double(double)>>;
+using OutType = double;
+using TestType = std::tuple<int, double, double, double, int, std::function<double(double)>, double>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace eremin_v_strongin_algorithm

tasks/eremin_v_strongin_algorithm/info.json

@@ -0,0 +1,9 @@
+{
+  "student": {
+    "first_name": "Василий",
+    "last_name": "Еремин",
+    "middle_name": "Евгеньевич",
+    "group_number": "3823Б1ФИ2",
+    "task_number": "3"
+  }
+}

tasks/eremin_v_strongin_algorithm/mpi/include/ops_mpi.hpp

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <vector>
+
+#include "eremin_v_strongin_algorithm/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace eremin_v_strongin_algorithm {
+
+class EreminVStronginAlgorithmMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit EreminVStronginAlgorithmMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  struct IntervalCharacteristic {
+    double value;
+    int index;
+  };
+
+  static double CalculateLipschitzEstimate(int rank, int size, const std::vector<double> &search_points,
+                                           const std::vector<double> &function_values);
+  static IntervalCharacteristic FindBestInterval(int rank, int size, const std::vector<double> &search_points,
+                                                 const std::vector<double> &function_values, double m_parameter);
+};
+
+}  // namespace eremin_v_strongin_algorithm

tasks/eremin_v_strongin_algorithm/mpi/src/ops_mpi.cpp

@@ -0,0 +1,168 @@
+#include "eremin_v_strongin_algorithm/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cmath>
+#include <cstddef>
+#include <functional>
+#include <tuple>
+#include <vector>
+
+#include "eremin_v_strongin_algorithm/common/include/common.hpp"
+
+namespace eremin_v_strongin_algorithm {
+
+EreminVStronginAlgorithmMPI::EreminVStronginAlgorithmMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool EreminVStronginAlgorithmMPI::ValidationImpl() {
+  auto &input = GetInput();
+
+  double lower_bound = std::get<0>(input);
+  double upper_bound = std::get<1>(input);
+  double epsilon = std::get<2>(input);
+  int max_iters = std::get<3>(input);
+
+  return (lower_bound < upper_bound) && (epsilon > 0.0 && epsilon <= (upper_bound - lower_bound)) &&
+         (max_iters > 0 && max_iters <= 100000000) && (lower_bound >= -1e9 && lower_bound <= 1e9) &&
+         (upper_bound >= -1e9 && upper_bound <= 1e9) && (GetOutput() == 0);
+}
+
+bool EreminVStronginAlgorithmMPI::PreProcessingImpl() {
+  return true;
+}
+
+double EreminVStronginAlgorithmMPI::CalculateLipschitzEstimate(int rank, int size,
+                                                               const std::vector<double> &search_points,
+                                                               const std::vector<double> &function_values) {
+  double lipschitz_estimate = 0.0;
+  for (std::size_t i = 1 + static_cast<std::size_t>(rank); i < search_points.size();
+       i += static_cast<std::size_t>(size)) {
+    double interval_width = search_points[i] - search_points[i - 1];
+    double value_difference = std::abs(function_values[i] - function_values[i - 1]);
+    double current_slope = value_difference / interval_width;
+    lipschitz_estimate = std::max(current_slope, lipschitz_estimate);
+  }
+
+  double global_lipschitz_estimate = 0.0;
+  MPI_Allreduce(&lipschitz_estimate, &global_lipschitz_estimate, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
+
+  return global_lipschitz_estimate;
+}
+
+EreminVStronginAlgorithmMPI::IntervalCharacteristic EreminVStronginAlgorithmMPI::FindBestInterval(
+    int rank, int size, const std::vector<double> &search_points, const std::vector<double> &function_values,
+    double m_parameter) {
+  IntervalCharacteristic local{.value = -1e18, .index = 1};
+
+  for (std::size_t i = 1 + static_cast<std::size_t>(rank); i < search_points.size();
+       i += static_cast<std::size_t>(size)) {
+    double interval_width = search_points[i] - search_points[i - 1];
+    double value_difference = function_values[i] - function_values[i - 1];
+
+    double characteristic = (m_parameter * interval_width) +
+                            ((value_difference * value_difference) / (m_parameter * interval_width)) -
+                            (2.0 * (function_values[i] + function_values[i - 1]));
+
+    if (characteristic > local.value) {
+      local.value = characteristic;
+      local.index = static_cast<int>(i);
+    }
+  }
+
+  IntervalCharacteristic global{};
+  MPI_Allreduce(&local, &global, 1, MPI_DOUBLE_INT, MPI_MAXLOC, MPI_COMM_WORLD);
+  return global;
+}
+
+bool EreminVStronginAlgorithmMPI::RunImpl() {
+  int rank = 0;
+  int size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  double lower_bound = 0.0;
+  double upper_bound = 0.0;
+  double epsilon = 0.0;
+  int max_iterations = 0;
+
+  if (rank == 0) {
+    auto &input = GetInput();
+    lower_bound = std::get<0>(input);
+    upper_bound = std::get<1>(input);
+    epsilon = std::get<2>(input);
+    max_iterations = std::get<3>(input);
+  }
+
+  MPI_Bcast(&lower_bound, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  MPI_Bcast(&upper_bound, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  MPI_Bcast(&epsilon, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  MPI_Bcast(&max_iterations, 1, MPI_INT, 0, MPI_COMM_WORLD);
+
+  std::function<double(double)> objective_function = std::get<4>(GetInput());
+  ;
+
+  std::vector<double> search_points = {lower_bound, upper_bound};
+  std::vector<double> function_values = {objective_function(lower_bound), objective_function(upper_bound)};
+  search_points.reserve(max_iterations + 2);
+  function_values.reserve(max_iterations + 2);
+
+  int current_iteration = 0;
+  double r_coefficient = 2.0;
+  double max_interval_width = upper_bound - lower_bound;
+
+  while (max_interval_width > epsilon && current_iteration < max_iterations) {
+    ++current_iteration;
+
+    double lipschitz_estimate = CalculateLipschitzEstimate(rank, size, search_points, function_values);
+
+    double m_parameter = (lipschitz_estimate > 0.0) ? r_coefficient * lipschitz_estimate : 1.0;
+
+    auto best_interval = FindBestInterval(rank, size, search_points, function_values, m_parameter);
+    int best_interval_index = best_interval.index;
+
+    double left_point = search_points[best_interval_index - 1];
+    double right_point = search_points[best_interval_index];
+    double left_value = function_values[best_interval_index - 1];
+    double right_value = function_values[best_interval_index];
+
+    double new_point = 0.0;
+    double new_value = 0.0;
+
+    if (rank == 0) {
+      new_point = (0.5 * (left_point + right_point)) - ((right_value - left_value) / (2.0 * m_parameter));
+
+      if (new_point <= left_point || new_point >= right_point) {
+        new_point = 0.5 * (left_point + right_point);
+      }
+
+      new_value = objective_function(new_point);
+    }
+    MPI_Bcast(&new_point, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+    MPI_Bcast(&new_value, 1, MPI_DOUBLE, 0, MPI_COMM_WORLD);
+
+    search_points.insert(search_points.begin() + static_cast<std::ptrdiff_t>(best_interval_index), new_point);
+    function_values.insert(function_values.begin() + static_cast<std::ptrdiff_t>(best_interval_index), new_value);
+
+    max_interval_width = 0.0;
+    for (std::size_t i = 1 + static_cast<std::size_t>(rank); i < search_points.size();
+         i += static_cast<std::size_t>(size)) {
+      double current_width = search_points[i] - search_points[i - 1];
+      max_interval_width = std::max(current_width, max_interval_width);
+    }
+    double local_max_interval_width = max_interval_width;
+    MPI_Allreduce(&local_max_interval_width, &max_interval_width, 1, MPI_DOUBLE, MPI_MAX, MPI_COMM_WORLD);
+  }
+  GetOutput() = *std::ranges::min_element(function_values);
+  return true;
+}
+
+bool EreminVStronginAlgorithmMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace eremin_v_strongin_algorithm

tasks/eremin_v_strongin_algorithm/report.md

@@ -0,0 +1,138 @@
+# Алгоритм глобального поиска (Стронгина) для одномерных задач оптимизации. Распараллеливание по характеристикам.
+
+- **Студент:** Еремин Василий Егвеньевич, группа 3823Б1ФИ2
+- **Технология:** SEQ | MPI
+- **Вариант:** №11
+
+## 1. Введение
+
+**Цель работы:** Реализация и сравнительный анализ последовательной и параллельной версий алгоритма Стронгина для поиска глобального минимума функции на заданном отрезке.
+
+**Задачи:**
+1. Реализовать последовательную версию алгоритма Стронгина.
+2. Реализовать параллельную версию с использованием технологии MPI.
+3. Провести сравнительный анализ производительности и эффективности обеих реализаций.
+
+## 2. Постановка задачи
+
+**Задача**: Найти глобальный минимум непрерывной функции $f(x)$ на отрезке $[a,b]$ с заданной точностью ϵ или за ограниченное число итераций
+
+**Описание метода решения:**
+Алгоритм Стронгина — это итерационный метод, который на каждом шаге использует информацию о всех предыдущих испытаниях для выбора следующей точки. Основная идея заключается в вычислении **характеристики** каждого интервала между соседними точками. Характеристика отражает вероятность нахождения глобального минимума внутри данного интервала.
+
+
+**Входные данные:**
+- `lower_bound` ($a$), `upper_bound` ($b$) — границы поиска.
+- `epsilon` ($\epsilon$) — требуемая точность.
+- `max_iterations` — ограничение на количество шагов.
+- `objective_function` ($f(x)$) — минимизируемая функция.
+
+**Выходные данные:**
+- Минимальное найденное значение функции на отрезке.
+
+**Ограничения:** - Границы отрезка: $[-10^9, 10^9]$
+- Максимальное число итераций: $100,000,000$
+
+## 3. Описание алгоритма (последовательного)
+
+**Алгоритм работы:**
+1. **Инициализация:** Вычисляются значения функции в граничных точках $a$ и $b$.
+2. **Оценка константы Липшица:** На основе всех проведенных испытаний вычисляется наклон:
+   $$M = \max \frac{|f(x_i) - f(x_{i-1})|}{x_i - x_{i-1}}$$
+3. **Параметр плотности:** $m = r \cdot M$ (где $r > 1$ — параметр надежности, в реализации $r=2.0$).
+4. **Вычисление характеристик:** Для каждого интервала $(x_{i-1}, x_i)$ рассчитывается значение $R_i$.
+5. **Выбор нового испытания:** Выбирается интервал с максимальным $R_i$, и внутри него вычисляется новая точка $x_{new}$.
+6. **Критерий остановки:** Если длина максимального интервала становится меньше $\epsilon$ или достигнут лимит итераций.
+
+
+## 4. Схема распараллеливания (MPI)
+
+Основная вычислительная нагрузка в алгоритме приходится на перебор всех интервалов для поиска константы Липшица и расчет характеристик.
+
+**Алгоритм параллельного вычисления:**
+1. **Рассылка параметров:** Процесс 0 получает входные данные и рассылает их всем остальным через `MPI_Bcast`.
+2. **Распределенный поиск наклона:** Каждый процесс обходит свою часть интервалов (с шагом `size`), вычисляя локальный максимум $M_{local}$.
+3. **Глобальная синхронизация:** С помощью `MPI_Allreduce` находится общее значение $M$ для всех процессов.
+4. **Параллельный расчет характеристик:** Процессы вычисляют $R_i$ для "своих" интервалов и находят локальный максимум характеристики.
+5. **Выбор лучшего интервала:** Используется `MPI_Allreduce` с операцией `MPI_MAXLOC` для нахождения индекса интервала с глобально максимальной характеристикой.
+6. **Обновление данных:** Процесс 0 вычисляет новую точку и её значение, затем рассылает их всем (`MPI_Bcast`). Все процессы синхронно вставляют точку в свои локальные векторы.
+**Принцип разделения отрезков:**
+
+```cpp
+
+for (std::size_t i = 1 + rank; i < search_points.size(); i += size) {
+    // Вычисления для конкретного интервала i
+}
+```
+
+## 5. Детали реализации
+**Дополнительные функции в тестах:**
+- **MPI_MAXLOC:** Позволяет эффективно находить не только значение максимальной характеристики, но и ранг процесса/индекс интервала, которому она принадлежит.
+- **Динамические массивы:** Использованы `std::vector` для хранения точек испытаний.
+- **Устойчивость:** Добавлена проверка, чтобы новая точка $x_{new}$ не выходила за границы интервала из-за погрешностей типа `double`.
+
+## 6. Экспериментальная среда
+- **Hardware/OS:** Apple M1 Pro, 6 ядер производительности и 2 эффективности, 16 ГБ, Ubuntu 24.04.2 (DevContainer)
+- **Toolchain:** GCC 13.3.0, C++20, CMake 3.28.3, build type Release
+- **Environment:** `PPC_NUM_PROC` = 8
+
+## 7. Результаты и обсуждение
+
+### 7.1 Проверка корректности
+
+**Методы верификации корректности:**
+
+1.  **Сравнение с эталоном:**
+    * Используются аналитически известные точки минимума для тестовых функций.
+    * Проверка осуществляется через `expected_result_` в юнит-тестах.
+
+2.  **Автоматизированное тестирование:**
+    * Реализованы тесты для 5 различных сценариев, включающих тригонометрические, полиномиальные и экспоненциальные функции.
+    * Сравнение последовательной (SEQ) и параллельной (MPI) версий подтверждает идентичность логики.
+
+3.  **Допустимая погрешность:**
+    ```cpp
+    double tolerance = 1e-2;
+    return std::abs(output_data - expected_result_) <= tolerance;
+    ```
+    * Установленная точность позволяет нивелировать разницу в точности вычислений `double` на разных архитектурах и учитывать дискретность шага алгоритма.
+**Тестовые случаи:**
+* **Интервалы:** от узких $[-5, 5]$ до широких $[-2, 100]$.
+* **Функции:**
+    * $f(x) = x^2$ — классическая парабола.
+    * $f(x) = \sin(x)$ — периодическая функция с множеством локальных экстремумов.
+    * $f(x) = x^4 - 3x^2$ — функция с двумя симметричными минимумами.
+    * $f(x) = e^x$ — монотонная функция (минимум на границе).
+
+**Результат:** Все тесты проходят успешно, что подтверждает корректность обеих реализаций.
+
+### 7.2 Производительность
+
+- **Сложная тестовая функция:** $f(x) = 0.002 \cdot x^2 + 5 \cdot \sin(30 \cdot x) + \sin(200 * \sin(50 \cdot x)) + 0.1 \cdot \cos(300 \cdot x)$
+- **Лимит итераций:** `40 000`
+- **Точность (epsilon):** `0.0001`
+
+**Полученные результаты:**
+
+| **Режим** | **Количество процессов** | **Время, с** | **Speedup** | **Efficiency** |
+|-----------|--------------------------|--------------|-------------|----------------|
+| SEQ       | 1                        | 4.25         | 1.00        | N/A            |
+| MPI       | 2                        | 2.83         | 1.57        | 79%            |
+| MPI       | 4                        | 2.22         | 2.00        | 50%            |
+| MPI       | 6                        | 2.81         | 1.58        | 26%            |
+
+
+## 8. Заключение
+
+В ходе выполнения работы были успешно реализованы последовательная и параллельная (MPI) версии алгоритма Стронгина для глобальной одномерной оптимизации. 
+
+Основные выводы:
+* Параллельная версия корректно находит глобальный минимум функции наравне с последовательной, что подтверждено набором автоматизированных тестов.
+* Реализованная схема распараллеливания по характеристикам интервалов демонстрирует стабильное ускорение на многоядерных системах.
+* Выявлено, что для алгоритмов с высокой частотой синхронизаций (как в случае с методом Стронгина) оптимальное число процессов ограничено балансом между вычислительной сложностью целевой функции и задержками обмена данными в MPI-среде.
+
+Данная реализация может быть использована для ускорения поиска экстремумов в задачах, где вычисление целевой функции является ресурсоемкой операцией.
+
+## 9. Источники
+1. [Презентация по курсу](https://learning-process.github.io/parallel_programming_slides/slides/01-intro.pdf)
+2. [Wikipedia](https://ru.wikipedia.org/wiki/Метод_Стронгина)