Рычкова Диана. Технология SEQ-MPI. Сумма элементов матрицы по столбцам. Вариант 12

tasks/rychkova_d_sum_matrix_columns/common/include/common.hpp

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

tasks/rychkova_d_sum_matrix_columns/info.json

@@ -0,0 +1,9 @@
+{
+    "student": {
+        "first_name": "Diana",
+        "last_name": "Rychkova",
+        "middle_name": "Dmitrievna",
+        "group_number": "3823B1FI3",
+        "task_number": "1"
+    }
+}

tasks/rychkova_d_sum_matrix_columns/mpi/include/ops_mpi.hpp

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

tasks/rychkova_d_sum_matrix_columns/mpi/src/ops_mpi.cpp

@@ -0,0 +1,87 @@
+#include "rychkova_d_sum_matrix_columns/mpi/include/ops_mpi.hpp"
+
+#include <mpi.h>
+
+#include <algorithm>
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "rychkova_d_sum_matrix_columns/common/include/common.hpp"
+
+namespace rychkova_d_sum_matrix_columns {
+
+RychkovaDSumMatrixColumnsMPI::RychkovaDSumMatrixColumnsMPI(const InType& in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = OutType{};
+}
+
+bool RychkovaDSumMatrixColumnsMPI::ValidationImpl() {
+  const auto& input = GetInput();
+
+  if (input.empty()) {
+    return true;
+  }
+
+  size_t cols = input[0].size();
+  for (const auto& row : input) {
+    if (row.size() != cols) {
+      return false;
+    }
+  }
+
+  return GetOutput().empty();
+}
+
+bool RychkovaDSumMatrixColumnsMPI::PreProcessingImpl() {
+  const auto& input = GetInput();
+
+  if (input.empty()) {
+    GetOutput() = std::vector<int>{};
+    return true;
+  }
+
+  GetOutput() = std::vector<int>(input[0].size(), 0);
+  return true;
+}
+
+bool RychkovaDSumMatrixColumnsMPI::RunImpl() {
+  const auto& input = GetInput();
+  auto& output = GetOutput();
+
+  if (input.empty()) {
+    return true;
+  }
+
+  int rank = 0;
+  int size = 0;
+  MPI_Comm_rank(MPI_COMM_WORLD, &rank);
+  MPI_Comm_size(MPI_COMM_WORLD, &size);
+
+  size_t num_rows = input.size();
+  size_t num_cols = input[0].size();
+
+  size_t rows_per_process = num_rows / size;
+  size_t remainder = num_rows % size;
+  size_t start_row = (rank * rows_per_process) + std::min(static_cast<size_t>(rank), remainder);
+  size_t end_row = start_row + rows_per_process + (std::cmp_less(rank, remainder) ? 1 : 0);
+
+  std::vector<int> local_sums(num_cols, 0);
+
+  for (size_t i = start_row; i < end_row; ++i) {
+    for (size_t j = 0; j < num_cols; ++j) {
+      local_sums[j] += input[i][j];
+    }
+  }
+
+  MPI_Allreduce(local_sums.data(), output.data(), static_cast<int>(num_cols), MPI_INT, MPI_SUM, MPI_COMM_WORLD);
+
+  return true;
+}
+
+bool RychkovaDSumMatrixColumnsMPI::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace rychkova_d_sum_matrix_columns

tasks/rychkova_d_sum_matrix_columns/seq/include/ops_seq.hpp

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

tasks/rychkova_d_sum_matrix_columns/seq/src/ops_seq.cpp

@@ -0,0 +1,71 @@
+#include "rychkova_d_sum_matrix_columns/seq/include/ops_seq.hpp"
+
+#include <cstddef>
+#include <vector>
+
+#include "rychkova_d_sum_matrix_columns/common/include/common.hpp"
+
+namespace rychkova_d_sum_matrix_columns {
+
+RychkovaDSumMatrixColumnsSEQ::RychkovaDSumMatrixColumnsSEQ(const InType& in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+  GetOutput() = OutType{};
+}
+
+bool RychkovaDSumMatrixColumnsSEQ::ValidationImpl() {
+  const auto& input = GetInput();
+
+  if (input.empty()) {
+    return true;
+  }
+
+  size_t cols = input[0].size();
+  for (const auto& row : input) {
+    if (row.size() != cols) {
+      return false;
+    }
+  }
+
+  return GetOutput().empty();
+}
+
+bool RychkovaDSumMatrixColumnsSEQ::PreProcessingImpl() {
+  const auto& input = GetInput();
+
+  if (input.empty()) {
+    GetOutput().clear();
+    return true;
+  }
+
+  const size_t cols = input[0].size();
+  GetOutput().assign(cols, 0);
+  return true;
+}
+
+bool RychkovaDSumMatrixColumnsSEQ::RunImpl() {
+  const auto& input = GetInput();
+  auto& output = GetOutput();
+
+  if (input.empty()) {
+    return true;
+  }
+
+  if (output.empty() || output.size() != input[0].size()) {
+    output.assign(input[0].size(), 0);
+  }
+
+  for (const auto& row : input) {
+    for (size_t j = 0; j < row.size(); ++j) {
+      output[j] += row[j];
+    }
+  }
+
+  return true;
+}
+
+bool RychkovaDSumMatrixColumnsSEQ::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace rychkova_d_sum_matrix_columns

tasks/rychkova_d_sum_matrix_columns/settings.json

@@ -0,0 +1,7 @@
+{
+  "tasks_type": "processes",
+  "tasks": {
+    "mpi": "enabled",
+    "seq": "enabled"
+  }
+}

tasks/rychkova_d_sum_matrix_columns/tests/.clang-tidy

@@ -0,0 +1,13 @@
+InheritParentConfig: true
+
+Checks: >
+  -modernize-loop-convert,
+  -cppcoreguidelines-avoid-goto,
+  -cppcoreguidelines-avoid-non-const-global-variables,
+  -misc-use-anonymous-namespace,
+  -modernize-use-std-print,
+  -modernize-type-traits
+
+CheckOptions:
+  - key: readability-function-cognitive-complexity.Threshold
+    value: 50  # Relaxed for tests

tasks/rychkova_d_sum_matrix_columns/tests/functional/main.cpp

@@ -0,0 +1,82 @@
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cstddef>
+#include <string>
+#include <tuple>
+#include <vector>
+
+#include "rychkova_d_sum_matrix_columns/common/include/common.hpp"
+#include "rychkova_d_sum_matrix_columns/mpi/include/ops_mpi.hpp"
+#include "rychkova_d_sum_matrix_columns/seq/include/ops_seq.hpp"
+#include "util/include/func_test_util.hpp"
+#include "util/include/util.hpp"
+
+namespace rychkova_d_sum_matrix_columns {
+
+class RychkovaRunFuncTestsMatrixColumns : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
+ public:
+  static std::string PrintTestParam(const TestType &test_param) {
+    return std::get<2>(test_param);
+  }
+
+ protected:
+  void SetUp() override {
+    TestType params = std::get<static_cast<std::size_t>(ppc::util::GTestParamIndex::kTestParams)>(GetParam());
+    input_matrix_ = std::get<0>(params);
+    expected_output_ = std::get<1>(params);
+  }
+
+  bool CheckTestOutputData(OutType &output_data) final {
+    if (output_data.size() != expected_output_.size()) {
+      return false;
+    }
+
+    for (size_t i = 0; i < output_data.size(); ++i) {
+      if (output_data[i] != expected_output_[i]) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  InType GetTestInputData() final {
+    return input_matrix_;
+  }
+
+ private:
+  InType input_matrix_;
+  OutType expected_output_;
+};
+
+namespace {
+
+TEST_P(RychkovaRunFuncTestsMatrixColumns, SumMatrixColumnsTest) {
+  ExecuteTest(GetParam());
+}
+
+const std::array<TestType, 4> kTestParam = {
+    std::make_tuple(std::vector<std::vector<int>>{}, std::vector<int>{}, "empty_matrix"),
+
+    std::make_tuple(std::vector<std::vector<int>>{{5}}, std::vector<int>{5}, "1x1_matrix"),
+
+    std::make_tuple(std::vector<std::vector<int>>{{1, 2, 3}, {4, 5, 6}}, std::vector<int>{5, 7, 9}, "2x3_matrix"),
+
+    std::make_tuple(std::vector<std::vector<int>>{{1, -2}, {-3, 4}, {5, -6}}, std::vector<int>{3, -4},
+                    "3x2_matrix_with_negatives")};
+
+const auto kTestTasksList = std::tuple_cat(ppc::util::AddFuncTask<RychkovaDSumMatrixColumnsMPI, InType>(
+                                               kTestParam, PPC_SETTINGS_rychkova_d_sum_matrix_columns),
+                                           ppc::util::AddFuncTask<RychkovaDSumMatrixColumnsSEQ, InType>(
+                                               kTestParam, PPC_SETTINGS_rychkova_d_sum_matrix_columns));
+
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+
+const auto kPerfTestName = RychkovaRunFuncTestsMatrixColumns::PrintFuncTestName<RychkovaRunFuncTestsMatrixColumns>;
+
+INSTANTIATE_TEST_SUITE_P(MatrixColumnsTests, RychkovaRunFuncTestsMatrixColumns, kGtestValues, kPerfTestName);
+
+}  // namespace
+
+}  // namespace rychkova_d_sum_matrix_columns