Синев Тимур. Технология OMP. Умножение плотных матриц. Элементы типа double. Блочная схема, алгоритм Кэннона. Вариант 1

Testing/Temporary/CTestCostData.txt

@@ -0,0 +1 @@
+---

Testing/Temporary/LastTest.log

@@ -0,0 +1,3 @@
+Start testing: Mar 19 01:40 RTZ 2 (çèìà)
+----------------------------------------------------------
+End testing: Mar 19 01:40 RTZ 2 (çèìà)

tasks/timur_a_cannon/omp/include/ops_omp.hpp

@@ -0,0 +1,40 @@
+#pragma once
+#include <vector>
+
+#include "task/include/task.hpp"
+#include "timur_a_cannon/common/include/common.hpp"
+
+namespace timur_a_cannon {
+
+class TimurACannonMatrixMultiplicationOMP : public BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kOMP;
+  }
+
+  TimurACannonMatrixMultiplicationOMP() = default;
+  explicit TimurACannonMatrixMultiplicationOMP(const InType &in);
+  ~TimurACannonMatrixMultiplicationOMP() override = default;
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+  static void RotateBlocksA(std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz);
+  static void RotateBlocksB(std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz);
+  static void BlockMultiplyAccumulate(const std::vector<std::vector<double>> &a,
+                                      const std::vector<std::vector<double>> &b, std::vector<std::vector<double>> &c,
+                                      int b_size);
+
+  static void DistributeData(const std::vector<std::vector<double>> &src_a,
+                             const std::vector<std::vector<double>> &src_b,
+                             std::vector<std::vector<std::vector<std::vector<double>>>> &bl_a,
+                             std::vector<std::vector<std::vector<std::vector<double>>>> &bl_b, int b_size, int grid_sz);
+
+  static void CollectResult(const std::vector<std::vector<std::vector<std::vector<double>>>> &bl_c,
+                            std::vector<std::vector<double>> &res, int b_size, int grid_sz);
+};
+
+}  // namespace timur_a_cannon

tasks/timur_a_cannon/omp/src/ops_omp.cpp

@@ -0,0 +1,141 @@
+#include "timur_a_cannon/omp/include/ops_omp.hpp"
+
+#include <omp.h>
+
+#include <cstddef>
+#include <utility>
+#include <vector>
+
+#include "timur_a_cannon/common/include/common.hpp"
+
+namespace timur_a_cannon {
+
+TimurACannonMatrixMultiplicationOMP::TimurACannonMatrixMultiplicationOMP(const InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  GetInput() = in;
+}
+
+bool TimurACannonMatrixMultiplicationOMP::ValidationImpl() {
+  const auto &input = GetInput();
+  int b_size = std::get<0>(input);
+  const auto &mat_a = std::get<1>(input);
+  const auto &mat_b = std::get<2>(input);
+
+  return b_size > 0 && !mat_a.empty() && !mat_b.empty() && mat_a.size() == mat_a[0].size() &&
+         mat_a.size() == mat_b.size() && mat_a.size() % static_cast<size_t>(b_size) == 0;
+}
+
+bool TimurACannonMatrixMultiplicationOMP::PreProcessingImpl() {
+  GetOutput().clear();
+  return true;
+}
+
+void TimurACannonMatrixMultiplicationOMP::BlockMultiplyAccumulate(const std::vector<std::vector<double>> &a,
+                                                                  const std::vector<std::vector<double>> &b,
+                                                                  std::vector<std::vector<double>> &c, int b_size) {
+  for (int i = 0; i < b_size; ++i) {
+    for (int k = 0; k < b_size; ++k) {
+      double temp = a[i][k];
+      for (int j = 0; j < b_size; ++j) {
+        c[i][j] += temp * b[k][j];
+      }
+    }
+  }
+}
+
+void TimurACannonMatrixMultiplicationOMP::DistributeData(
+    const std::vector<std::vector<double>> &src_a, const std::vector<std::vector<double>> &src_b,
+    std::vector<std::vector<std::vector<std::vector<double>>>> &bl_a,
+    std::vector<std::vector<std::vector<std::vector<double>>>> &bl_b, int b_size, int grid_sz) {
+#pragma omp parallel for collapse(2) default(none) shared(src_a, src_b, bl_a, bl_b, b_size, grid_sz)
+  for (int i = 0; i < grid_sz; ++i) {
+    for (int j = 0; j < grid_sz; ++j) {
+      int shift = (i + j) % grid_sz;
+      for (int row = 0; row < b_size; ++row) {
+        for (int col = 0; col < b_size; ++col) {
+          bl_a[i][j][row][col] = src_a[(i * b_size) + row][((shift)*b_size) + col];
+          bl_b[i][j][row][col] = src_b[((shift)*b_size) + row][(j * b_size) + col];
+        }
+      }
+    }
+  }
+}
+
+void TimurACannonMatrixMultiplicationOMP::CollectResult(
+    const std::vector<std::vector<std::vector<std::vector<double>>>> &bl_c, std::vector<std::vector<double>> &res,
+    int b_size, int grid_sz) {
+#pragma omp parallel for collapse(2) default(none) shared(bl_c, res, b_size, grid_sz)
+  for (int i = 0; i < grid_sz; ++i) {
+    for (int j = 0; j < grid_sz; ++j) {
+      for (int row = 0; row < b_size; ++row) {
+        for (int col = 0; col < b_size; ++col) {
+          res[(i * b_size) + row][(j * b_size) + col] = bl_c[i][j][row][col];
+        }
+      }
+    }
+  }
+}
+
+void TimurACannonMatrixMultiplicationOMP::RotateBlocksA(
+    std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz) {
+#pragma omp parallel for default(none) shared(blocks, grid_sz)
+  for (int i = 0; i < grid_sz; ++i) {
+    auto first_block = std::move(blocks[i][0]);
+    for (int j = 0; j < grid_sz - 1; ++j) {
+      blocks[i][j] = std::move(blocks[i][j + 1]);
+    }
+    blocks[i][grid_sz - 1] = std::move(first_block);
+  }
+}
+
+void TimurACannonMatrixMultiplicationOMP::RotateBlocksB(
+    std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz) {
+#pragma omp parallel for default(none) shared(blocks, grid_sz)
+  for (int j = 0; j < grid_sz; ++j) {
+    auto first_block = std::move(blocks[0][j]);
+    for (int i = 0; i < grid_sz - 1; ++i) {
+      blocks[i][j] = std::move(blocks[i + 1][j]);
+    }
+    blocks[grid_sz - 1][j] = std::move(first_block);
+  }
+}
+
+bool TimurACannonMatrixMultiplicationOMP::RunImpl() {
+  const auto &input = GetInput();
+  int b_size = std::get<0>(input);
+  int n = static_cast<int>(std::get<1>(input).size());
+  int grid_sz = n / b_size;
+
+  using Matrix = std::vector<std::vector<double>>;
+  using BlockGrid = std::vector<std::vector<Matrix>>;
+  BlockGrid bl_a(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size))));
+  BlockGrid bl_b(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size))));
+  BlockGrid bl_c(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size, 0.0))));
+
+  DistributeData(std::get<1>(input), std::get<2>(input), bl_a, bl_b, b_size, grid_sz);
+
+  for (int step = 0; step < grid_sz; ++step) {
+#pragma omp parallel for collapse(2) default(none) shared(bl_a, bl_b, bl_c, b_size, grid_sz)
+    for (int i = 0; i < grid_sz; ++i) {
+      for (int j = 0; j < grid_sz; ++j) {
+        BlockMultiplyAccumulate(bl_a[i][j], bl_b[i][j], bl_c[i][j], b_size);
+      }
+    }
+    if (step < grid_sz - 1) {
+      RotateBlocksA(bl_a, grid_sz);
+      RotateBlocksB(bl_b, grid_sz);
+    }
+  }
+
+  Matrix res_mat(n, std::vector<double>(n));
+  CollectResult(bl_c, res_mat, b_size, grid_sz);
+
+  GetOutput() = std::move(res_mat);
+  return true;
+}
+
+bool TimurACannonMatrixMultiplicationOMP::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace timur_a_cannon

tasks/timur_a_cannon/seq/src/ops_seq.cpp

@@ -8,32 +8,29 @@
 
 namespace timur_a_cannon {
 
-TimurACannonMatrixMultiplication::TimurACannonMatrixMultiplication(const InType &in) {
+TimurACannonMatrixMultiplicationOMP::TimurACannonMatrixMultiplicationOMP(const InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   GetInput() = in;
 }
 
-bool TimurACannonMatrixMultiplication::ValidationImpl() {
+bool TimurACannonMatrixMultiplicationOMP::ValidationImpl() {
   const auto &input = GetInput();
   int b_size = std::get<0>(input);
   const auto &mat_a = std::get<1>(input);
   const auto &mat_b = std::get<2>(input);
 
-  if (b_size <= 0 || mat_a.empty() || mat_b.empty()) {
-    return false;
-  }
-  size_t n = mat_a.size();
-  return (n == mat_a[0].size() && n == mat_b.size() && n == mat_b[0].size() && (n % static_cast<size_t>(b_size) == 0));
+  return b_size > 0 && !mat_a.empty() && !mat_b.empty() && mat_a.size() == mat_a[0].size() &&
+         mat_a.size() == mat_b.size() && mat_a.size() % static_cast<size_t>(b_size) == 0;
 }
 
-bool TimurACannonMatrixMultiplication::PreProcessingImpl() {
+bool TimurACannonMatrixMultiplicationOMP::PreProcessingImpl() {
   GetOutput().clear();
   return true;
 }
 
-void TimurACannonMatrixMultiplication::BlockMultiplyAccumulate(const std::vector<std::vector<double>> &a,
-                                                               const std::vector<std::vector<double>> &b,
-                                                               std::vector<std::vector<double>> &c, int b_size) {
+void TimurACannonMatrixMultiplicationOMP::BlockMultiplyAccumulate(const std::vector<std::vector<double>> &a,
+                                                                  const std::vector<std::vector<double>> &b,
+                                                                  std::vector<std::vector<double>> &c, int b_size) {
   for (int i = 0; i < b_size; ++i) {
     for (int k = 0; k < b_size; ++k) {
       double temp = a[i][k];
@@ -44,27 +41,28 @@ void TimurACannonMatrixMultiplication::BlockMultiplyAccumulate(const std::vector
   }
 }
 
-void TimurACannonMatrixMultiplication::DistributeData(const std::vector<std::vector<double>> &src_a,
-                                                      const std::vector<std::vector<double>> &src_b,
-                                                      std::vector<std::vector<std::vector<std::vector<double>>>> &bl_a,
-                                                      std::vector<std::vector<std::vector<std::vector<double>>>> &bl_b,
-                                                      int b_size, int grid_sz) {
+void TimurACannonMatrixMultiplicationOMP::DistributeData(
+    const std::vector<std::vector<double>> &src_a, const std::vector<std::vector<double>> &src_b,
+    std::vector<std::vector<std::vector<std::vector<double>>>> &bl_a,
+    std::vector<std::vector<std::vector<std::vector<double>>>> &bl_b, int b_size, int grid_sz) {
+#pragma omp parallel for collapse(2) default(none) shared(src_a, src_b, bl_a, bl_b, b_size, grid_sz)
   for (int i = 0; i < grid_sz; ++i) {
     for (int j = 0; j < grid_sz; ++j) {
       int shift = (i + j) % grid_sz;
       for (int row = 0; row < b_size; ++row) {
         for (int col = 0; col < b_size; ++col) {
-          bl_a[i][j][row][col] = src_a[(i * b_size) + row][(shift * b_size) + col];
-          bl_b[i][j][row][col] = src_b[(shift * b_size) + row][(j * b_size) + col];
+          bl_a[i][j][row][col] = src_a[(i * b_size) + row][((shift)*b_size) + col];
+          bl_b[i][j][row][col] = src_b[((shift)*b_size) + row][(j * b_size) + col];
         }
       }
     }
   }
 }
 
-void TimurACannonMatrixMultiplication::CollectResult(
+void TimurACannonMatrixMultiplicationOMP::CollectResult(
     const std::vector<std::vector<std::vector<std::vector<double>>>> &bl_c, std::vector<std::vector<double>> &res,
     int b_size, int grid_sz) {
+#pragma omp parallel for collapse(2) default(none) shared(bl_c, res, b_size, grid_sz)
   for (int i = 0; i < grid_sz; ++i) {
     for (int j = 0; j < grid_sz; ++j) {
       for (int row = 0; row < b_size; ++row) {
@@ -76,8 +74,9 @@ void TimurACannonMatrixMultiplication::CollectResult(
   }
 }
 
-void TimurACannonMatrixMultiplication::RotateBlocksA(std::vector<std::vector<std::vector<std::vector<double>>>> &blocks,
-                                                     int grid_sz) {
+void TimurACannonMatrixMultiplicationOMP::RotateBlocksA(
+    std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz) {
+#pragma omp parallel for default(none) shared(blocks, grid_sz)
   for (int i = 0; i < grid_sz; ++i) {
     auto first_block = std::move(blocks[i][0]);
     for (int j = 0; j < grid_sz - 1; ++j) {
@@ -87,8 +86,9 @@ void TimurACannonMatrixMultiplication::RotateBlocksA(std::vector<std::vector<std
   }
 }
 
-void TimurACannonMatrixMultiplication::RotateBlocksB(std::vector<std::vector<std::vector<std::vector<double>>>> &blocks,
-                                                     int grid_sz) {
+void TimurACannonMatrixMultiplicationOMP::RotateBlocksB(
+    std::vector<std::vector<std::vector<std::vector<double>>>> &blocks, int grid_sz) {
+#pragma omp parallel for default(none) shared(blocks, grid_sz)
   for (int j = 0; j < grid_sz; ++j) {
     auto first_block = std::move(blocks[0][j]);
     for (int i = 0; i < grid_sz - 1; ++i) {
@@ -98,22 +98,22 @@ void TimurACannonMatrixMultiplication::RotateBlocksB(std::vector<std::vector<std
   }
 }
 
-bool TimurACannonMatrixMultiplication::RunImpl() {
+bool TimurACannonMatrixMultiplicationOMP::RunImpl() {
   const auto &input = GetInput();
   int b_size = std::get<0>(input);
   int n = static_cast<int>(std::get<1>(input).size());
   int grid_sz = n / b_size;
 
   using Matrix = std::vector<std::vector<double>>;
   using BlockGrid = std::vector<std::vector<Matrix>>;
-
   BlockGrid bl_a(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size))));
   BlockGrid bl_b(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size))));
   BlockGrid bl_c(grid_sz, std::vector<Matrix>(grid_sz, Matrix(b_size, std::vector<double>(b_size, 0.0))));
 
   DistributeData(std::get<1>(input), std::get<2>(input), bl_a, bl_b, b_size, grid_sz);
 
   for (int step = 0; step < grid_sz; ++step) {
+#pragma omp parallel for collapse(2) default(none) shared(bl_a, bl_b, bl_c, b_size, grid_sz)
     for (int i = 0; i < grid_sz; ++i) {
       for (int j = 0; j < grid_sz; ++j) {
         BlockMultiplyAccumulate(bl_a[i][j], bl_b[i][j], bl_c[i][j], b_size);
@@ -132,7 +132,7 @@ bool TimurACannonMatrixMultiplication::RunImpl() {
   return true;
 }
 
-bool TimurACannonMatrixMultiplication::PostProcessingImpl() {
+bool TimurACannonMatrixMultiplicationOMP::PostProcessingImpl() {
   return true;
 }
 

tasks/timur_a_cannon/tests/functional/main.cpp

@@ -9,6 +9,7 @@
 #include <vector>
 
 #include "timur_a_cannon/common/include/common.hpp"
+#include "timur_a_cannon/omp/include/ops_omp.hpp"
 #include "timur_a_cannon/seq/include/ops_seq.hpp"
 #include "util/include/func_test_util.hpp"
 #include "util/include/util.hpp"
@@ -92,8 +93,8 @@ const std::array<TestType, 8> kTestParam = {
                     std::vector<std::vector<double>>(9, std::vector<double>(9, 19.8)))};
 
 const auto kTestTasksList = std::tuple_cat(
-    ppc::util::AddFuncTask<TimurACannonMatrixMultiplication, InType>(kTestParam, PPC_SETTINGS_timur_a_cannon));
-
+    ppc::util::AddFuncTask<TimurACannonMatrixMultiplication, InType>(kTestParam, PPC_SETTINGS_timur_a_cannon),
+    ppc::util::AddFuncTask<TimurACannonMatrixMultiplicationOMP, InType>(kTestParam, PPC_SETTINGS_timur_a_cannon));
 const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 
 const auto kPerfTestName = TimurACannonFuncTests::PrintFuncTestName<TimurACannonFuncTests>;