Завьялов Алексей. Технология OMP. Умножение разреженных матриц. Элементы комплексного типа. Формат хранения матрицы – столбцовый (CCS). Вариант 7

tasks/zavyalov_a_complex_sparse_matrix_mult/omp/include/ops_omp.hpp

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

tasks/zavyalov_a_complex_sparse_matrix_mult/omp/src/ops_omp.cpp

@@ -0,0 +1,86 @@
+#include "zavyalov_a_complex_sparse_matrix_mult/omp/include/ops_omp.hpp"
+
+#include <omp.h>
+
+#include <cstddef>
+#include <map>
+#include <stdexcept>
+#include <utility>
+#include <vector>
+
+#include "util/include/util.hpp"
+#include "zavyalov_a_complex_sparse_matrix_mult/common/include/common.hpp"
+
+namespace zavyalov_a_compl_sparse_matr_mult {
+
+SparseMatrix ZavyalovAComplSparseMatrMultOMP::MultiplicateWithOmp(const SparseMatrix &matr_a,
+                                                                  const SparseMatrix &matr_b) {
+  if (matr_a.width != matr_b.height) {
+    throw std::invalid_argument("Incompatible matrix dimensions for multiplication");
+  }
+
+  int num_threads = ppc::util::GetNumThreads();
+
+  std::vector<std::map<std::pair<size_t, size_t>, Complex>> local_maps(num_threads);
+
+#pragma omp parallel for num_threads(num_threads) schedule(static) default(none) shared(matr_a, matr_b, local_maps)
+  for (size_t i = 0; i < matr_a.Count(); ++i) {
+    int tid = omp_get_thread_num();
+    size_t row_a = matr_a.row_ind[i];
+    size_t col_a = matr_a.col_ind[i];
+    Complex val_a = matr_a.val[i];
+
+    for (size_t j = 0; j < matr_b.Count(); ++j) {
+      if (col_a == matr_b.row_ind[j]) {
+        local_maps[tid][{row_a, matr_b.col_ind[j]}] += val_a * matr_b.val[j];
+      }
+    }
+  }
+
+  std::map<std::pair<size_t, size_t>, Complex> mp;
+  for (auto &lm : local_maps) {
+    for (auto &[key, value] : lm) {
+      mp[key] += value;
+    }
+  }
+
+  SparseMatrix res;
+  res.width = matr_b.width;
+  res.height = matr_a.height;
+  for (const auto &[key, value] : mp) {
+    res.val.push_back(value);
+    res.row_ind.push_back(key.first);
+    res.col_ind.push_back(key.second);
+  }
+
+  return res;
+}
+
+ZavyalovAComplSparseMatrMultOMP::ZavyalovAComplSparseMatrMultOMP(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool ZavyalovAComplSparseMatrMultOMP::ValidationImpl() {
+  const auto &matr_a = std::get<0>(GetInput());
+  const auto &matr_b = std::get<1>(GetInput());
+  return matr_a.width == matr_b.height;
+}
+
+bool ZavyalovAComplSparseMatrMultOMP::PreProcessingImpl() {
+  return true;
+}
+
+bool ZavyalovAComplSparseMatrMultOMP::RunImpl() {
+  const auto &matr_a = std::get<0>(GetInput());
+  const auto &matr_b = std::get<1>(GetInput());
+
+  GetOutput() = MultiplicateWithOmp(matr_a, matr_b);
+
+  return true;
+}
+
+bool ZavyalovAComplSparseMatrMultOMP::PostProcessingImpl() {
+  return true;
+}
+}  // namespace zavyalov_a_compl_sparse_matr_mult

tasks/zavyalov_a_complex_sparse_matrix_mult/tests/functional/main.cpp

@@ -11,6 +11,7 @@
 #include "util/include/func_test_util.hpp"
 #include "util/include/util.hpp"
 #include "zavyalov_a_complex_sparse_matrix_mult/common/include/common.hpp"
+#include "zavyalov_a_complex_sparse_matrix_mult/omp/include/ops_omp.hpp"
 #include "zavyalov_a_complex_sparse_matrix_mult/seq/include/ops_seq.hpp"
 
 namespace zavyalov_a_compl_sparse_matr_mult {
@@ -141,7 +142,9 @@ const std::array<TestType, 10> kTestParam = {
     std::make_tuple(1, 5, 3), std::make_tuple(4, 7, 2)};
 
 const auto kTestTasksList = std::tuple_cat(ppc::util::AddFuncTask<ZavyalovAComplSparseMatrMultSEQ, InType>(
-    kTestParam, PPC_SETTINGS_zavyalov_a_complex_sparse_matrix_mult));
+                                               kTestParam, PPC_SETTINGS_zavyalov_a_complex_sparse_matrix_mult),
+                                           ppc::util::AddFuncTask<ZavyalovAComplSparseMatrMultOMP, InType>(
+                                               kTestParam, PPC_SETTINGS_zavyalov_a_complex_sparse_matrix_mult));
 
 const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 

tasks/zavyalov_a_complex_sparse_matrix_mult/tests/performance/main.cpp

@@ -8,12 +8,13 @@
 
 #include "util/include/perf_test_util.hpp"
 #include "zavyalov_a_complex_sparse_matrix_mult/common/include/common.hpp"
+#include "zavyalov_a_complex_sparse_matrix_mult/omp/include/ops_omp.hpp"
 #include "zavyalov_a_complex_sparse_matrix_mult/seq/include/ops_seq.hpp"
 
 namespace zavyalov_a_compl_sparse_matr_mult {  // comm for ci12
 
 class ZavyalovAComplexSparseMatrMultPerfTest : public ppc::util::BaseRunPerfTests<InType, OutType> {
-  static constexpr size_t kCount = 15000;
+  static constexpr size_t kCount = 11000;
   InType input_data_;
 
   void SetUp() override {
@@ -81,8 +82,9 @@ TEST_P(ZavyalovAComplexSparseMatrMultPerfTest, RunPerfModes) {
 
 namespace {
 
-const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks<InType, ZavyalovAComplSparseMatrMultSEQ>(
-    PPC_SETTINGS_zavyalov_a_complex_sparse_matrix_mult);
+const auto kAllPerfTasks =
+    ppc::util::MakeAllPerfTasks<InType, ZavyalovAComplSparseMatrMultSEQ, ZavyalovAComplSparseMatrMultOMP>(
+        PPC_SETTINGS_zavyalov_a_complex_sparse_matrix_mult);
 
 const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);