Чащин Владимир. Технология TBB. Линейная фильтрация изображений (горизонтальное разбиение). Ядро Гаусса 3x3. Вариант 24.

tasks/chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp

@@ -6,11 +6,11 @@
 
 #include "task/include/task.hpp"
 
-namespace chaschin_v_linear_image_filtration_seq {
+namespace chaschin_v_linear_image_filtration {
 
 using InType = std::tuple<std::vector<float>, int, int>;
 using OutType = std::vector<float>;
 using TestType = std::tuple<int, std::string>;
 using BaseTask = ppc::task::Task<InType, OutType>;
 
-}  // namespace chaschin_v_linear_image_filtration_seq
+}  // namespace chaschin_v_linear_image_filtration

tasks/chaschin_vladimir_linear_image_filtration_seq/omp/include/ops_omp.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+
+#include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace chaschin_v_linear_image_filtration_omp {
+
+class ChaschinVLinearFiltrationOMP : public chaschin_v_linear_image_filtration::BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kOMP;
+  }
+  explicit ChaschinVLinearFiltrationOMP(const chaschin_v_linear_image_filtration::InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+inline float HorizontalFilterAtOMP(const std::vector<float> &img, int n, int x, int y);
+inline float VerticalFilterAtOMP(const std::vector<float> &temp, int n, int m, int x, int y);
+
+}  // namespace chaschin_v_linear_image_filtration_omp

tasks/chaschin_vladimir_linear_image_filtration_seq/omp/src/ops_omp.cpp

@@ -0,0 +1,97 @@
+#include "chaschin_vladimir_linear_image_filtration_seq/omp/include/ops_omp.hpp"
+
+#include <omp.h>
+
+#include <utility>
+#include <vector>
+
+#include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+namespace chaschin_v_linear_image_filtration_omp {
+
+ChaschinVLinearFiltrationOMP::ChaschinVLinearFiltrationOMP(const chaschin_v_linear_image_filtration::InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  auto in_copy = in;
+  GetInput() = std::move(in_copy);
+  this->GetOutput().clear();
+}
+
+bool ChaschinVLinearFiltrationOMP::ValidationImpl() {
+  const auto &in = GetInput();
+  const auto &image = std::get<0>(in);
+  return !image.empty();
+}
+
+bool ChaschinVLinearFiltrationOMP::PreProcessingImpl() {
+  return true;
+}
+
+inline float HorizontalFilterAtOMP(const std::vector<float> &img, int n, int x, int y) {
+  const int idx = (y * n) + x;
+
+  if (x == 0) {
+    return ((2.F * img[idx]) + img[idx + 1]) / 3.F;
+  }
+
+  if (x == n - 1) {
+    return (img[idx - 1] + (2.F * img[idx])) / 3.F;
+  }
+
+  return (img[idx - 1] + (2.F * img[idx]) + img[idx + 1]) / 4.F;
+}
+
+inline float VerticalFilterAtOMP(const std::vector<float> &temp, int n, int m, int x, int y) {
+  const int idx = (y * n) + x;
+
+  if (y == 0) {
+    return ((2.F * temp[idx]) + temp[idx + n]) / 3.F;
+  }
+
+  if (y == m - 1) {
+    return (temp[idx - n] + (2.F * temp[idx])) / 3.F;
+  }
+
+  return (temp[idx - n] + (2.F * temp[idx]) + temp[idx + n]) / 4.F;
+}
+
+bool ChaschinVLinearFiltrationOMP::RunImpl() {
+  const auto &in = GetInput();
+  const auto &image = std::get<0>(in);
+  int n = std::get<1>(in);
+  int m = std::get<2>(in);
+
+  auto &out = GetOutput();
+  out.resize(static_cast<std::vector<float>::size_type>(n) * static_cast<std::vector<float>::size_type>(m));
+
+  std::vector<float> temp(static_cast<std::vector<float>::size_type>(n) *
+                          static_cast<std::vector<float>::size_type>(m));
+
+  // ---------- горизонтальная фильтрация ----------
+#pragma omp parallel for default(none) shared(n, m, image, temp)
+  for (int yi = 0; yi < m; ++yi) {
+    for (int xf = 0; xf < n; ++xf) {
+      temp[(yi * n) + xf] = HorizontalFilterAtOMP(image, n, xf, yi);
+    }
+  }
+
+  // ---------- вертикальная фильтрация ----------
+#pragma omp parallel for default(none) shared(n, m, temp, out)
+  for (int yi = 0; yi < m; ++yi) {
+    for (int xy = 0; xy < n; ++xy) {
+      out[(yi * n) + xy] = VerticalFilterAtOMP(temp, n, m, xy, yi);
+    }
+  }
+
+#pragma omp barrier
+
+#if _OPENMP >= 201811
+  omp_pause_resource_all(omp_pause_hard);
+#endif
+
+  return true;
+}
+
+bool ChaschinVLinearFiltrationOMP::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace chaschin_v_linear_image_filtration_omp

tasks/chaschin_vladimir_linear_image_filtration_seq/seq/include/ops_seq.hpp

@@ -7,12 +7,12 @@
 
 namespace chaschin_v_linear_image_filtration_seq {
 
-class ChaschinVLinearFiltrationSEQ : public BaseTask {
+class ChaschinVLinearFiltrationSEQ : public chaschin_v_linear_image_filtration::BaseTask {
  public:
   static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
     return ppc::task::TypeOfTask::kSEQ;
   }
-  explicit ChaschinVLinearFiltrationSEQ(const InType &in);
+  explicit ChaschinVLinearFiltrationSEQ(const chaschin_v_linear_image_filtration::InType &in);
 
  private:
   bool ValidationImpl() override;

tasks/chaschin_vladimir_linear_image_filtration_seq/seq/src/ops_seq.cpp

@@ -6,7 +6,7 @@
 #include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
 namespace chaschin_v_linear_image_filtration_seq {
 
-ChaschinVLinearFiltrationSEQ::ChaschinVLinearFiltrationSEQ(const InType &in) {
+ChaschinVLinearFiltrationSEQ::ChaschinVLinearFiltrationSEQ(const chaschin_v_linear_image_filtration::InType &in) {
   SetTypeOfTask(GetStaticTypeOfTask());
   auto in_copy = in;
   GetInput() = std::move(in_copy);

tasks/chaschin_vladimir_linear_image_filtration_seq/tbb/include/ops_tbb.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <vector>
+
+#include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+#include "task/include/task.hpp"
+
+namespace chaschin_v_linear_image_filtration_tbb {
+
+class ChaschinVLinearFiltrationTBB : public chaschin_v_linear_image_filtration::BaseTask {
+ public:
+  static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() {
+    return ppc::task::TypeOfTask::kTBB;
+  }
+  explicit ChaschinVLinearFiltrationTBB(const chaschin_v_linear_image_filtration::InType &in);
+
+ private:
+  bool ValidationImpl() override;
+  bool PreProcessingImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+};
+
+inline float HorizontalFilterAtTBB(const std::vector<float> &img, int n, int x, int y);
+inline float VerticalFilterAtTBB(const std::vector<float> &temp, int n, int m, int x, int y);
+
+}  // namespace chaschin_v_linear_image_filtration_tbb

tasks/chaschin_vladimir_linear_image_filtration_seq/tbb/src/ops_tbb.cpp

@@ -0,0 +1,87 @@
+#include "chaschin_vladimir_linear_image_filtration_seq/tbb/include/ops_tbb.hpp"
+
+#include <tbb/tbb.h>
+
+#include <utility>
+#include <vector>
+
+#include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+
+namespace chaschin_v_linear_image_filtration_tbb {
+
+ChaschinVLinearFiltrationTBB::ChaschinVLinearFiltrationTBB(const chaschin_v_linear_image_filtration::InType &in) {
+  SetTypeOfTask(GetStaticTypeOfTask());
+  auto in_copy = in;
+  GetInput() = std::move(in_copy);
+  this->GetOutput().clear();
+}
+
+bool ChaschinVLinearFiltrationTBB::ValidationImpl() {
+  const auto &in = GetInput();
+  const auto &image = std::get<0>(in);
+  return !image.empty();
+}
+
+bool ChaschinVLinearFiltrationTBB::PreProcessingImpl() {
+  return true;
+}
+
+inline float HorizontalFilterAtTBB(const std::vector<float> &img, int n, int x, int y) {
+  const int idx = (y * n) + x;
+  if (x == 0) {
+    return ((2.F * img[idx]) + img[idx + 1]) / 3.F;
+  }
+  if (x == n - 1) {
+    return (img[idx - 1] + (2.F * img[idx])) / 3.F;
+  }
+  return (img[idx - 1] + (2.F * img[idx]) + img[idx + 1]) / 4.F;
+}
+
+inline float VerticalFilterAtTBB(const std::vector<float> &temp, int n, int m, int x, int y) {
+  const int idx = (y * n) + x;
+  if (y == 0) {
+    return ((2.F * temp[idx]) + temp[idx + n]) / 3.F;
+  }
+  if (y == m - 1) {
+    return (temp[idx - n] + (2.F * temp[idx])) / 3.F;
+  }
+  return (temp[idx - n] + (2.F * temp[idx]) + temp[idx + n]) / 4.F;
+}
+
+bool ChaschinVLinearFiltrationTBB::RunImpl() {
+  const auto &in = GetInput();
+  const auto &image = std::get<0>(in);
+  int n = std::get<1>(in);
+  int m = std::get<2>(in);
+
+  auto &out = GetOutput();
+  out.resize(static_cast<size_t>(n) * m);
+
+  std::vector<float> temp(static_cast<size_t>(n) * m);
+
+  // ---------- горизонтальная фильтрация ----------
+  tbb::parallel_for(tbb::blocked_range<int>(0, m), [&](const tbb::blocked_range<int> &r) {
+    for (int yi = r.begin(); yi < r.end(); ++yi) {
+      for (int xf = 0; xf < n; ++xf) {
+        temp[(yi * n) + xf] = HorizontalFilterAtTBB(image, n, xf, yi);
+      }
+    }
+  });
+
+  // ---------- вертикальная фильтрация ----------
+  tbb::parallel_for(tbb::blocked_range<int>(0, m), [&](const tbb::blocked_range<int> &r) {
+    for (int yi = r.begin(); yi < r.end(); ++yi) {
+      for (int xy = 0; xy < n; ++xy) {
+        out[(yi * n) + xy] = VerticalFilterAtTBB(temp, n, m, xy, yi);
+      }
+    }
+  });
+
+  return true;
+}
+
+bool ChaschinVLinearFiltrationTBB::PostProcessingImpl() {
+  return true;
+}
+
+}  // namespace chaschin_v_linear_image_filtration_tbb

tasks/chaschin_vladimir_linear_image_filtration_seq/tests/functional/main.cpp

@@ -9,11 +9,13 @@
 #include <vector>
 
 #include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+#include "chaschin_vladimir_linear_image_filtration_seq/omp/include/ops_omp.hpp"
 #include "chaschin_vladimir_linear_image_filtration_seq/seq/include/ops_seq.hpp"
+#include "chaschin_vladimir_linear_image_filtration_seq/tbb/include/ops_tbb.hpp"
 #include "util/include/func_test_util.hpp"
 #include "util/include/util.hpp"
 
-namespace chaschin_v_linear_image_filtration_seq {
+namespace chaschin_v_linear_image_filtration {
 
 class ChaschinVRunFuncTests : public ppc::util::BaseRunFuncTests<InType, OutType, TestType> {
  public:
@@ -104,20 +106,29 @@ TEST_P(ChaschinVRunFuncTests, MatmulFromPic) {
   ExecuteTest(GetParam());
 }
 
-const std::array<TestType, 5> kTestParam = {
-    std::make_tuple(4, "4"),   std::make_tuple(8, "8"),   std::make_tuple(16, "16"),
-    std::make_tuple(32, "32"), std::make_tuple(64, "64"),
+const std::array<TestType, 5> kTestParamSeq = {
+    std::make_tuple(4, "seq_4"),   std::make_tuple(8, "seq_8"),   std::make_tuple(16, "seq_16"),
+    std::make_tuple(32, "seq_32"), std::make_tuple(64, "seq_64"),
 };
 
-const auto kTestTasksList = std::tuple_cat(
-    ppc::util::AddFuncTask<ChaschinVLinearFiltrationSEQ, InType>(kTestParam, PPC_SETTINGS_example_processes));
+const std::array<TestType, 5> kTestParamOmp = {
+    std::make_tuple(4, "omp_4"),   std::make_tuple(8, "omp_8"),   std::make_tuple(16, "omp_16"),
+    std::make_tuple(32, "omp_32"), std::make_tuple(64, "omp_64"),
+};
 
-const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
+const auto kTestTasksList =
+    std::tuple_cat(ppc::util::AddFuncTask<chaschin_v_linear_image_filtration_seq::ChaschinVLinearFiltrationSEQ, InType>(
+                       kTestParamSeq, PPC_SETTINGS_chaschin_vladimir_linear_image_filtration_seq),
+                   ppc::util::AddFuncTask<chaschin_v_linear_image_filtration_omp::ChaschinVLinearFiltrationOMP, InType>(
+                       kTestParamOmp, PPC_SETTINGS_chaschin_vladimir_linear_image_filtration_seq),
+                   ppc::util::AddFuncTask<chaschin_v_linear_image_filtration_tbb::ChaschinVLinearFiltrationTBB, InType>(
+                       kTestParamSeq, PPC_SETTINGS_chaschin_vladimir_linear_image_filtration_seq));
 
+const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList);
 const auto kPerfTestName = ChaschinVRunFuncTests::PrintFuncTestName<ChaschinVRunFuncTests>;
 
 INSTANTIATE_TEST_SUITE_P(LinearGaussianTests, ChaschinVRunFuncTests, kGtestValues, kPerfTestName);
 
 }  // namespace
 
-}  // namespace chaschin_v_linear_image_filtration_seq
+}  // namespace chaschin_v_linear_image_filtration

tasks/chaschin_vladimir_linear_image_filtration_seq/tests/performance/main.cpp

@@ -6,10 +6,12 @@
 #include <vector>
 
 #include "chaschin_vladimir_linear_image_filtration_seq/common/include/common.hpp"
+#include "chaschin_vladimir_linear_image_filtration_seq/omp/include/ops_omp.hpp"
 #include "chaschin_vladimir_linear_image_filtration_seq/seq/include/ops_seq.hpp"
+#include "chaschin_vladimir_linear_image_filtration_seq/tbb/include/ops_tbb.hpp"
 #include "util/include/perf_test_util.hpp"
 
-namespace chaschin_v_linear_image_filtration_seq {
+namespace chaschin_v_linear_image_filtration {
 
 class ChaschinVRunPerfTests : public ppc::util::BaseRunPerfTests<InType, OutType> {
   static constexpr int kCount = 512;
@@ -93,14 +95,16 @@ TEST_P(ChaschinVRunPerfTests, RunPerfModes) {
 namespace {
 
 const auto kAllPerfTasks =
-    ppc::util::MakeAllPerfTasks<InType, ChaschinVLinearFiltrationSEQ>(PPC_SETTINGS_example_processes);
+    ppc::util::MakeAllPerfTasks<InType, chaschin_v_linear_image_filtration_seq::ChaschinVLinearFiltrationSEQ,
+                                chaschin_v_linear_image_filtration_omp::ChaschinVLinearFiltrationOMP,
+                                chaschin_v_linear_image_filtration_tbb::ChaschinVLinearFiltrationTBB>(
+        PPC_SETTINGS_chaschin_vladimir_linear_image_filtration_seq);
 
 const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks);
-
 const auto kPerfTestName = ChaschinVRunPerfTests::CustomPerfTestName;
 
 INSTANTIATE_TEST_SUITE_P(RunModeTests, ChaschinVRunPerfTests, kGtestValues, kPerfTestName);
 
 }  // namespace
 
-}  // namespace chaschin_v_linear_image_filtration_seq
+}  // namespace chaschin_v_linear_image_filtration