Волков Алексей. Технология SEQ-MPI. Подсчет числа слов в строке. Вариант 24 (#118)

## Описание

- **Задача**: Подсчет числа слов в строке
- **Вариант**: 24
- **Технология**: SEQ. MPI
- **Описание**: в рамках работы была выполнена последовательная (SEQ) и
параллельная (MPI) реализация алгоритма подсчета слов. Последовательный
алгоритм основан на эффективной однопроходной "машине состояний",
которая отслеживает нахождение внутри слова или разделителя.
Параллельный алгоритм MPI использует схему "Master/Worker", где процесс
0 распределяет данные равными частями с помощью MPI_Scatterv.

---

## Чек-лист

- [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: fleezeex

tasks/volkov_a_count_word_line/common/include/common.hpp

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

tasks/volkov_a_count_word_line/data/Tolstoy Leo. War and Peace.txt

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

tasks/volkov_a_count_word_line/info.json

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

tasks/volkov_a_count_word_line/mpi/include/ops_mpi.hpp

@@ -0,0 +1,132 @@
+#include "volkov_a_count_word_line/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "volkov_a_count_word_line/common/include/common.hpp"
+
+namespace volkov_a_count_word_line {
+
+namespace {
+
+bool IsTokenChar(char c) {
+  const bool is_alpha = (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+  const bool is_digit = (c >= '0' && c <= '9');
+  const bool is_special = (c == '-' || c == '_');
+  return is_alpha || is_digit || is_special;
+}
+
+int CountWordsInChunk(const std::vector<char> &data, int valid_size) {
+  int count = 0;
+  bool in_word = false;
+
+  for (int i = 0; i < valid_size; ++i) {
+    if (IsTokenChar(data[i])) {
+      if (!in_word) {
+        in_word = true;
+        count++;
+      }
+    } else {
+      in_word = false;
+    }
+  }
+
+  if (in_word && static_cast<size_t>(valid_size) < data.size() && IsTokenChar(data[valid_size])) {
+    count--;
+  }
+
+  return count;
+}
+
+int CountWordsSeq(const std::string &str) {
+  int count = 0;
+  bool in_word = false;
+  for (char c : str) {
+    if (IsTokenChar(c)) {
+      if (!in_word) {
+        in_word = true;
+        count++;
+      }
+    } else {
+      in_word = false;
+    }
+  }
+  return count;
+}
+
+}  // namespace
+
+VolkovACountWordLineMPI::VolkovACountWordLineMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = 0;
+}
+
+bool VolkovACountWordLineMPI::ValidationImpl() {
+  return true;
+}
+
+bool VolkovACountWordLineMPI::PreProcessingImpl() {
+  return true;
+}
+
+bool VolkovACountWordLineMPI::RunImpl() {
+  int rank = 0;
+  int world_size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+
+  std::string &input_str = GetInput();
+
+  if (input_str.empty()) {
+    GetOutput() = 0;
+    return true;
+  }
+
+  if (static_cast<size_t>(world_size) > input_str.size()) {
+    if (rank == 0) {
+      GetOutput() = CountWordsSeq(input_str);
+    }
+    MPI_Bcast(&GetOutput(), 1, MPI_INT, 0, MPI_COMM_WORLD);
+    return true;
+  }
+
+  size_t remainder = input_str.size() % static_cast<size_t>(world_size);
+  size_t padding = (static_cast<size_t>(world_size) - remainder) % static_cast<size_t>(world_size);
+  input_str.append(padding + static_cast<size_t>(world_size), ' ');
+
+  int chunk_size = static_cast<int>(input_str.size() / static_cast<size_t>(world_size));
+
+  std::vector<int> send_counts(world_size);
+  std::vector<int> displs(world_size);
+
+  if (rank == 0) {
+    for (int i = 0; i < world_size; ++i) {
+      send_counts[i] = chunk_size + 1;
+      displs[i] = i * chunk_size;
+    }
+  }
+
+  std::vector<char> local_data(chunk_size + 1);
+
+  MPI_Scatterv(input_str.data(), send_counts.data(), displs.data(), MPI_CHAR, local_data.data(), chunk_size + 1,
+               MPI_CHAR, 0, MPI_COMM_WORLD);
+
+  int local_words = CountWordsInChunk(local_data, chunk_size);
+  int total_words = 0;
+
+  MPI_Allreduce(&local_words, &total_words, 1, MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+
+  GetOutput() = total_words;
+
+  return true;
+}
+
+bool VolkovACountWordLineMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace volkov_a_count_word_line

tasks/volkov_a_count_word_line/mpi/src/ops_mpi.cpp

@@ -0,0 +1,124 @@
+# Подсчет числа слов в строке
+
+- **Студент:** Волков Алексей Иванович, 3823Б1ФИ2
+- **Технология:** SEQ, MPI
+- **Вариант:** 24
+
+## 1. Введение
+
+Подсчет слов является фундаментальной задачей при обработке текстов. При работе с очень большими текстовыми объемами последовательное выполнение этой задачи может стать узким местом. Целью данной работы является разработка параллельного алгоритма для подсчета слов с использованием технологии MPI (Message Passing Interface) и сравнение его производительности с эталонной последовательной реализацией.
+
+## 2. Постановка задачи
+
+**Задача:** Необходимо подсчитать общее количество "слов" в заданной входной строке.
+
+-   **Входные данные:** строка символов `std::string`,
+-   **Выходные данные:** целое число `int`, представляющее общее количество слов,
+-   **Определение слова:** "словом" считается непрерывная последовательность символов, которая включает:
+    -   буквы латинского алфавита в верхнем и нижнем регистре (`a-z`, `A-Z`);
+    -   цифры (`0-9`);
+    -   символы дефиса (`-`) и подчеркивания (`_`).
+-   **Ограничения:** слова разделяются одним или несколькими символами-разделителями, которые не входят в определение "слова". Входная строка может быть пустой, может не содержать слов, а также может начинаться или заканчиваться разделителями.
+
+## 3. Описание алгоритма (базового/последовательного)
+
+Для последовательной реализации был выбран однопроходный алгоритм, основанный на концепции конечного автомата (машины состояний). Алгоритм проходит по строке символ за символом, отслеживая одно из двух состояний:
+
+1.  `IN_WORD` — текущий символ является частью слова.
+2.  `IN_SEPARATOR` — текущий символ является разделителем.
+
+Логика работы следующая:
+-   изначально автомат находится в состоянии `IN_SEPARATOR`;
+-   при переходе из состояния `IN_SEPARATOR` в `IN_WORD` (т.е. когда после разделителя встречается первый символ слова), счетчик слов увеличивается на единицу;
+-   при переходе из `IN_WORD` в `IN_SEPARATOR`, состояние просто меняется;
+-   если состояние не меняется (например, два символа слова подряд), никаких действий со счетчиком не происходит.
+Этот подход позволяет обойтись без создания подстрок или сложных манипуляций с памятью, обеспечивая высокую производительность за счет одного линейного прохода по данным.
+
+## 4. Схема распараллеливания
+
+Параллельная версия реализована с использованием MPI по модели "Master/Worker". Процесс с рангом 0 выступает в роли "мастера", а все остальные процессы (включая ранг 0) — в роли "воркеров".
+
+1.  **Распределение данных:**
+    -   процесс 0 определяет общую длину входной строки и рассылает это значение всем остальным процессам с помощью коллективной операции `MPI_Bcast`;
+    -   строка делится на N примерно равных непрерывных частей, где N — общее число процессов;
+    -   для распределения этих частей по всем процессам используется операция `MPI_Scatterv`, так как она позволяет работать с частями неодинакового размера (что актуально, если длина строки не делится нацело на число процессов).
+
+2.  **Схема коммуникаций и обработка границ:**
+    -   главная проблема параллельного подсчета — слова, "разрезанные" на границе двух частей, принадлежащих разным процессам. Чтобы решить эту проблему, каждый процесс должен знать, каким символом закончилась часть его левого соседа;
+    -   для этого используется операция `MPI_Sendrecv`. Каждый процесс `p` отправляет свой последний символ процессу `p+1` и одновременно получает последний символ от процесса `p-1`. Это позволяет каждому процессу корректно определить, является ли первое слово в его части новым или продолжением слова из предыдущей части. `MPI_Sendrecv` гарантирует отсутствие взаимоблокировок при обмене.
+
+3.  **Агрегация результатов:**
+    -   каждый процесс выполняет локальный подсчет слов в своей части данных с учетом полученного граничного символа;
+    -   локальные результаты со всех процессов собираются на процессе 0 и суммируются с помощью коллективной операции `MPI_Reduce` с оператором `MPI_SUM`.
+
+
+## 5. Детали реализации
+
+Реализация задачи выполнена на языке C++ и разделена на несколько логических компонентов в соответствии со структурой предоставленного фреймворка.
+
+### Структура кода
+
+-   **`common/include/common.hpp`**: общий заголовочный файл, определяющий типы данных для задачи:
+    -   `InType = std::string`: входные данные — стандартная строка;
+    -   `OutType = int`: выходные данные — целое число (количество слов);
+    -   `BaseTask`: "псевдоним" для базового класса `ppc::task::Task`,
+
+-   **`seq/`**: директория с последовательной реализацией:
+    -   `ops_seq.hpp`: объявление класса `VolkovACountWordLineSEQ`;
+    -   `ops_seq.cpp`: реализация методов класса и вспомогательных функций,
+
+-   **`mpi/`**: директория с параллельной реализацией:
+    -   `ops_mpi.hpp`: объявление класса `VolkovACountWordLineMPI`;
+    -   `ops_mpi.cpp`: реализация методов класса и вспомогательных функций для MPI,
+
+-   **`tests/`**: содержит функциональные и производительные тесты для проверки корректности и измерения производительности.
+
+### Ключевые классы и функции
+
+Решение инкапсулировано в классах `VolkovACountWordLineSEQ` и `VolkovACountWordLineMPI`, унаследованных от `BaseTask`. Основная вычислительная логика находится в переопределенном методе `RunImpl`.
+
+Для повышения читаемости, снижения когнитивной сложности основная логика подсчета слов была вынесена во внутренние вспомогательные функции, помещенные в анонимное пространство имен в соответствующих .cpp файлах:
+
+1.  **`bool IsTokenChar(char c)`**:
+    -   простая функция-предикат, которая возвращает `true`, если переданный символ является частью слова (буква, цифра, `_` или `-`), и `false` в противном случае. Функция была вынесена для переиспользования и улучшения читаемости основного алгоритма,
+
+2.  **`int CountWords(const char* data, size_t n)` (в `ops_seq.cpp`)**:
+    -   эта функция реализует основной алгоритм подсчета слов на основе "машины состояний" с двумя состояниями (`IN_WORD`, `IN_SEPARATOR`). Она проходит по данным за один проход, что обеспечивает высокую производительность,
+
+3.  **`int CountWordsInChunk(const std::vector<char>& data, char prev_char)` (в `ops_mpi.cpp`)**:
+    -   адаптированная версия `CountWords` для MPI-реализации. Она принимает дополнительный аргумент `prev_char` — последний символ из блока данных предыдущего процесса. Этот символ используется для определения начального состояния машины состояний, что позволяет корректно обрабатывать слова, "разрезанные" на границах между процессами.
+
+
+## 6. Экспериментальные результаты
+
+### Окружение
+
+-   **CPU:** Intel(R) Core(TM) i5-10400F CPU @ 2.90GHz (6 ядер, 12 потоков)
+-   **ОС:** Ubuntu 22.04.2 LTS (запущенная через Docker Engive v28.5.2 на Windows 11)
+-   **Компилятор:** g++ (Ubuntu 13.3.0-6ubuntu2~24.04) 13.3.0
+
+### Производительность
+
+Для тестов производительности использовался сгенерированный текст длиной 10 миллионов символов. Измерения времени проводились для последовательной реализации и для MPI-реализации на 2, 4 и 8 процессах.
+
+| Режим | Число процессов | Время, с | Ускорение (Speedup) | Эффективность (Efficiency) |
+|:------|:----------------:|:---------|:--------------------|:---------------------------|
+| seq   | 1                | 0.0095    | 1.00                | 100.0%                    |
+| mpi   | 2                | 0.0065    | 1.46                | 73.0%                     |
+| mpi   | 4                | 0.0039    | 2.44                | 61.0%                     |
+| mpi   | 8                | 0.0051    | 1.86                | 23.3%                     |
+
+**Выводы:**
+Полученные результаты демонстрируют несколько ключевых аспектов параллельного выполнения данной задачи на рассматриваемом окружении:
+1. *эффективное масштабирование до 4 процессов:* при увеличении числа процессов с 1 до 4 наблюдается значительное ускорение (до 2.44x). Это подтверждает, что выбранный алгоритм распараллеливания с использованием MPI эффективно распределяет работу, и накладные расходы не перевешивают выгоду от параллельных вычислений;
+2. *деградация производительности на 8 процессах:* время выполнения увеличилось с 0.0039 с до 0.0051 с, а эффективность упала до 23.3%. Это классический и довольно интересный пример ситуации, когда накладные расходы на параллелизм превысили выгоду.
+
+## 7. Выводы
+
+В ходе работы была успешно реализована и протестирована параллельная версия алгоритма подсчета слов в строке с использованием технологии MPI. Алгоритм продемонстрировал значительное ускорение по сравнению с последовательной версией, подтвердив эффективность выбранной схемы распараллеливания. Вот так :)
+
+## 8. Источники:
+
+1.  лекции и практики курса "Параллельное программирование для кластерных систем";
+2.  стандарт MPI (форум MPI);
+3.  документация по C++;

tasks/volkov_a_count_word_line/report.md

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