Зенин Антон. Технология SEQ-MPI. Сумма значений по столбцам матрицы. Вариант 12. (#60)

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

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

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

- **Задача**: Сумма значений по столбцам матрицы
- **Вариант**: 12
- **Технология**: SEQ,, MPI
- **Описание** вашей реализации и отчёта.  
Реализованы последовательная (SEQ) и параллельная (MPI) версии алгоритма
вычисления суммы значений матрицы по столбцам. В последовтельной версии
выполняется полный проход по матрице в формате row-major, и каждый
элемент добавляется к соответствующей сумме столбца. В параллельной
MPI-версии матрица распределяется по столбцам между процессами. Главный
процесс формирует буфер с данными столбцов, перераспределённых по
адресатам, и рассылает их с помощью MPI_Scatterv. Каждый процесс
локально суммирует значения своих столбцов. Затем локальные результаты
собираются на процессе 0 через MPI_Gatherv, после чего итоговый вектор
сумм рассылается всем процессам при помощи MPI_Bcast для корректной
валидации.

---

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

tasks/zenin_a_sum_values_by_columns_matrix/common/include/common.hpp

@@ -0,0 +1,16 @@
+#pragma once
+
+#include <cstddef>
+#include <tuple>
+#include <vector>
+
+#include "task/include/task.hpp"
+
+namespace zenin_a_sum_values_by_columns_matrix {
+
+using InType = std::tuple<size_t, size_t, std::vector<double>>;  // rows -> columns -> matrix
+using OutType = std::vector<double>;
+using TestType = std::tuple<size_t, size_t>;
+using BaseTask = ppc::task::Task<InType, OutType>;
+
+}  // namespace zenin_a_sum_values_by_columns_matrix

tasks/zenin_a_sum_values_by_columns_matrix/info.json

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

tasks/zenin_a_sum_values_by_columns_matrix/mpi/include/ops_mpi.hpp

@@ -0,0 +1,27 @@
+#pragma once
+#include <cstddef>
+#include <vector>
+
+#include "task/include/task.hpp"
+#include "zenin_a_sum_values_by_columns_matrix/common/include/common.hpp"
+
+namespace zenin_a_sum_values_by_columns_matrix {
+
+class ZeninASumValuesByColumnsMatrixMPI : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kMPI;
+  }
+  explicit ZeninASumValuesByColumnsMatrixMPI(const InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  static void FillSendBuffer(const std::vector<double> &mat, std::vector<double> &sendbuf, size_t rows, size_t cols,
+                             size_t base, size_t rest, int world_size);
+};
+
+}  // namespace zenin_a_sum_values_by_columns_matrix

tasks/zenin_a_sum_values_by_columns_matrix/mpi/src/ops_mpi.cpp

@@ -0,0 +1,126 @@
+#include "zenin_a_sum_values_by_columns_matrix/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <cmath>
+#include <cstddef>
+#include <stdexcept>
+#include <tuple>
+#include <utility>
+#include <vector>
+
+#include "zenin_a_sum_values_by_columns_matrix/common/include/common.hpp"
+
+namespace zenin_a_sum_values_by_columns_matrix {
+
+ZeninASumValuesByColumnsMatrixMPI::ZeninASumValuesByColumnsMatrixMPI(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = OutType{};
+}
+
+bool ZeninASumValuesByColumnsMatrixMPI::ValidationImpl() {
+  auto &input = GetInput();
+  return ((std::get<0>(input)) * std::get<1>(input) == std::get<2>(input).size() && (GetOutput().empty()));
+}
+
+bool ZeninASumValuesByColumnsMatrixMPI::PreProcessingImpl() {
+  int rank = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  if (rank != 0) {
+    return true;
+  }
+  GetOutput().clear();
+  return true;
+}
+
+void ZeninASumValuesByColumnsMatrixMPI::FillSendBuffer(const std::vector<double> &mat, std::vector<double> &sendbuf,
+                                                       size_t rows, size_t cols, size_t base, size_t rest,
+                                                       int world_size) {
+  size_t pos = 0;
+  for (int proc = 0; proc < world_size; proc++) {
+    auto proc_size = static_cast<size_t>(proc);
+    size_t pc_begin = (proc_size * base) + (std::cmp_less(proc_size, rest) ? proc_size : rest);
+    size_t pc_end = pc_begin + (base + (std::cmp_less(proc_size, rest) ? 1 : 0));
+    for (size_t col = pc_begin; col < pc_end; col++) {
+      for (size_t row = 0; row < rows; row++) {
+        sendbuf[pos++] = mat[(row * cols) + col];
+      }
+    }
+  }
+}
+
+bool ZeninASumValuesByColumnsMatrixMPI::RunImpl() {
+  auto rows = static_cast<size_t>(std::get<0>(GetInput()));
+  auto cols = static_cast<size_t>(std::get<1>(GetInput()));
+  const std::vector<double> &mat = std::get<2>(GetInput());
+
+  std::vector<double> &global_sum = GetOutput();
+
+  int rank = 0;
+  int world_size = 0;
+
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &world_size);
+
+  const size_t base = cols / static_cast<size_t>(world_size);
+  const size_t rest = cols % static_cast<size_t>(world_size);
+
+  const size_t my_cols = base + (std::cmp_less(static_cast<size_t>(rank), rest) ? 1 : 0);
+
+  std::vector<int> sendcounts(static_cast<size_t>(world_size));
+  std::vector<int> displs(static_cast<size_t>(world_size));
+  if (rank == 0) {
+    int offset = 0;
+    for (int proc = 0; proc < world_size; proc++) {
+      size_t pc = base + (std::cmp_less(static_cast<size_t>(proc), rest) ? 1 : 0);
+      sendcounts[proc] = static_cast<int>(pc * rows);
+      displs[proc] = offset;
+      offset += sendcounts[proc];
+    }
+  }
+
+  std::vector<double> sendbuf;
+  if (rank == 0) {
+    sendbuf.resize(rows * cols);
+    FillSendBuffer(mat, sendbuf, rows, cols, base, rest, world_size);
+  }
+  std::vector<double> local_block(rows * my_cols);
+  MPI_Scatterv(sendbuf.data(), sendcounts.data(), displs.data(), MPI_DOUBLE, local_block.data(),
+               static_cast<int>(local_block.size()), MPI_DOUBLE, 0, MPI_COMM_WORLD);
+
+  std::vector<double> local_sum(my_cols, 0.0);
+  for (size_t col_id = 0; col_id < my_cols; col_id++) {
+    for (size_t row_id = 0; row_id < rows; row_id++) {
+      local_sum[col_id] += local_block[(col_id * rows) + row_id];
+    }
+  }
+  std::vector<int> recvcounts(static_cast<size_t>(world_size));
+  std::vector<int> recvdispls(static_cast<size_t>(world_size));
+
+  if (rows == 0) {
+    throw std::runtime_error("Matrix has zero rows");
+  }
+
+  if (rank == 0) {
+    size_t offset = 0;
+    for (int proc = 0; proc < world_size; proc++) {
+      recvcounts[proc] = sendcounts[proc] / static_cast<int>(rows);
+      recvdispls[proc] = static_cast<int>(offset);
+      offset += static_cast<size_t>(recvcounts[proc]);
+    }
+    global_sum.assign(cols, 0.0);
+  }
+
+  MPI_Gatherv(local_sum.data(), static_cast<int>(my_cols), MPI_DOUBLE, global_sum.data(), recvcounts.data(),
+              recvdispls.data(), MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  global_sum.resize(cols);
+  MPI_Bcast(global_sum.data(), static_cast<int>(cols), MPI_DOUBLE, 0, MPI_COMM_WORLD);
+  return true;
+}
+
+bool ZeninASumValuesByColumnsMatrixMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace zenin_a_sum_values_by_columns_matrix