Unify task namespaces and refactor common functionality.

Replaced per-implementation task namespaces with a unified namespace `nesterov_a_test_task`. Introduced a common header to centralize shared definitions. Standardized task inheritance by introducing `BaseTask` and refactored related boilerplate for consistency.

Author: allnes

modules/core/perf/include/perf.hpp

@@ -24,9 +24,9 @@ struct PerfResults {
 template <typename InType, typename OutType>
 class Perf {
  public:
-  // Init performance analysis with initialized task and initialized data
+  // Init performance analysis with an initialized task and initialized data
   explicit Perf(const TaskPtr<InType, OutType>& task_ptr) : task_(task_ptr) {
-    task_ptr->GetStateOfTesting() = Task<InType, OutType>::StateOfTesting::kPerf;
+    task_ptr->GetStateOfTesting() = StateOfTesting::kPerf;
   }
   // Check performance of full task's pipeline:  PreProcessing() ->
   // Validation() -> Run() -> PostProcessing()

modules/core/task/include/task.hpp

@@ -17,13 +17,14 @@ using namespace std::chrono;
 
 namespace ppc::core {
 
-// Memory of inputs and outputs need to be initialized before create object of
+enum TypeOfTask : uint8_t { kALL, kMPI, kOMP, kSEQ, kSTL, kTBB, kUnknown };
+enum StateOfTesting : uint8_t { kFunc, kPerf };
+
+// Memory of inputs and outputs need to be initialized before create an object of
 // Task class
 template <typename InType, typename OutType>
 class Task {
  public:
-  enum StateOfTesting : uint8_t { kFunc, kPerf };
-
   explicit Task(StateOfTesting /*state_of_testing*/ = StateOfTesting::kFunc) {
     auto custom_terminate = []() {
       std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT! \n"
@@ -67,6 +68,9 @@ class Task {
   // get state of testing
   StateOfTesting &GetStateOfTesting() { return state_of_testing_; }
 
+  // get a type of task
+  static constexpr TypeOfTask GetTypeOfTask() { return TypeOfTask::kUnknown; }
+
   InType &GetInput() { return input_; }
 
   OutType &GetOutput() { return output_; }

modules/core/util/include/test_util.hpp

@@ -7,7 +7,7 @@
 
 namespace ppc::util {
 
-enum TestParamIndex : uint8_t { kTaskGetter, kNameTest, kTestParams };
+enum GTestParamIndex : uint8_t { kTaskGetter, kNameTest, kTestParams };
 
 inline std::string GetStringParamName(ppc::core::PerfResults::TypeOfRunning type_of_running) {
   if (type_of_running == core::PerfResults::kTaskRun) {
@@ -19,6 +19,28 @@ inline std::string GetStringParamName(ppc::core::PerfResults::TypeOfRunning type
   return "none";
 }
 
+inline std::string GetStringTaskType(ppc::core::TypeOfTask type_of_task) {
+  if (type_of_task == ppc::core::TypeOfTask::kALL) {
+    return "all";
+  }
+  if (type_of_task == ppc::core::TypeOfTask::kSTL) {
+    return "stl";
+  }
+  if (type_of_task == ppc::core::TypeOfTask::kOMP) {
+    return "omp";
+  }
+  if (type_of_task == ppc::core::TypeOfTask::kMPI) {
+    return "mpi";
+  }
+  if (type_of_task == ppc::core::TypeOfTask::kTBB) {
+    return "tbb";
+  }
+  if (type_of_task == ppc::core::TypeOfTask::kSEQ) {
+    return "seq";
+  }
+  return "unknown";
+}
+
 template <typename InType, typename OutType, typename TestType = void>
 using FuncTestParam = std::tuple<std::function<ppc::core::TaskPtr<InType, OutType>(InType)>, std::string, TestType>;
 
@@ -32,8 +54,8 @@ template <typename InType, typename OutType>
 class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, OutType>> {
  public:
   static std::string CustomPerfTestName(const ::testing::TestParamInfo<PerfTestParam<InType, OutType>>& info) {
-    return ppc::util::GetStringParamName(std::get<TestParamIndex::kTestParams>(info.param)) + "_" +
-           std::get<TestParamIndex::kNameTest>(info.param);
+    return ppc::util::GetStringParamName(std::get<GTestParamIndex::kTestParams>(info.param)) + "_" +
+           std::get<GTestParamIndex::kNameTest>(info.param);
   }
 
  protected:
@@ -42,9 +64,9 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
   virtual InType GetTestInputData() = 0;
 
   void ExecuteTest(const PerfTestParam<InType, OutType>& perf_test_param) {
-    auto task_getter = std::get<TestParamIndex::kTaskGetter>(perf_test_param);
-    auto test_name = std::get<TestParamIndex::kNameTest>(perf_test_param);
-    auto mode = std::get<TestParamIndex::kTestParams>(perf_test_param);
+    auto task_getter = std::get<GTestParamIndex::kTaskGetter>(perf_test_param);
+    auto test_name = std::get<GTestParamIndex::kNameTest>(perf_test_param);
+    auto mode = std::get<GTestParamIndex::kTestParams>(perf_test_param);
 
     task_ = task_getter(GetTestInputData());
     ppc::core::Perf perf(task_);
@@ -74,10 +96,14 @@ class BaseRunPerfTests : public ::testing::TestWithParam<PerfTestParam<InType, O
   ppc::core::TaskPtr<InType, OutType> task_;
 };
 
-#define ADD_PERF_MODES(TaskType, InputTypeParam)                                                            \
-  std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>, ppc::util::GetNamespace<TaskType>(),     \
-                  ppc::core::PerfResults::TypeOfRunning::kPipeline),                                        \
-      std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>, ppc::util::GetNamespace<TaskType>(), \
+#define ADD_PERF_MODES(TaskType, InputTypeParam)                                            \
+  std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                          \
+                  std::string(ppc::util::GetNamespace<TaskType>()) + std::string("_") +     \
+                      ppc::util::GetStringTaskType(TaskType::GetTypeOfTask()),              \
+                  ppc::core::PerfResults::TypeOfRunning::kPipeline),                        \
+      std::make_tuple(ppc::core::TaskGetter<TaskType, InputTypeParam>,                      \
+                      std::string(ppc::util::GetNamespace<TaskType>()) + std::string("_") + \
+                          ppc::util::GetStringTaskType(TaskType::GetTypeOfTask()),          \
                       ppc::core::PerfResults::TypeOfRunning::kTaskRun)
 
 template <typename T, typename TestType>
@@ -100,13 +126,13 @@ class BaseRunFuncTests : public ::testing::TestWithParam<FuncTestParam<InType, O
   template <typename Derived>
   static std::string PrintFuncTestName(const GTestFuncParam<InType, OutType, TestType>& info) {
     RequireStaticInterface<Derived>();
-    TestType test_param = std::get<ppc::util::TestParamIndex::kTestParams>(info.param);
-    return std::get<TestParamIndex::kNameTest>(info.param) + "_" + Derived::PrintTestParam(test_param);
+    TestType test_param = std::get<ppc::util::GTestParamIndex::kTestParams>(info.param);
+    return std::get<GTestParamIndex::kNameTest>(info.param) + "_" + Derived::PrintTestParam(test_param);
   }
 
  protected:
   void ExecuteTest(FuncTestParam<InType, OutType, TestType> test_param) {
-    task_ = std::get<TestParamIndex::kTaskGetter>(test_param)(GetTestInputData());
+    task_ = std::get<GTestParamIndex::kTaskGetter>(test_param)(GetTestInputData());
     ASSERT_TRUE(task_->Validation());
     ASSERT_TRUE(task_->PreProcessing());
     ASSERT_TRUE(task_->Run());
@@ -129,16 +155,18 @@ auto ExpandToValues(const Tuple& t) {
   return ExpandToValuesImpl(t, std::make_index_sequence<kN>{});
 }
 
-#define INIT_TASK_GENERATOR(InTypeParam, SizesParam)                                                                  \
-  template <typename Task, std::size_t... Is>                                                                         \
-  auto GenTaskTuplesImpl(std::index_sequence<Is...>) {                                                                \
-    return std::make_tuple(std::make_tuple(ppc::core::TaskGetter<Task, InTypeParam>, ppc::util::GetNamespace<Task>(), \
-                                           SizesParam[Is])...);                                                       \
-  }                                                                                                                   \
-                                                                                                                      \
-  template <typename Task>                                                                                            \
-  auto TaskListGenerator() {                                                                                          \
-    return GenTaskTuplesImpl<Task>(std::make_index_sequence<SizesParam.size()>{});                                    \
+#define INIT_TASK_GENERATOR(InTypeParam, SizesParam)                                                         \
+  template <typename Task, std::size_t... Is>                                                                \
+  auto GenTaskTuplesImpl(std::index_sequence<Is...>) {                                                       \
+    return std::make_tuple(std::make_tuple(ppc::core::TaskGetter<Task, InTypeParam>,                         \
+                                           std::string(ppc::util::GetNamespace<Task>()) + std::string("_") + \
+                                               ppc::util::GetStringTaskType(Task::GetTypeOfTask()),          \
+                                           SizesParam[Is])...);                                              \
+  }                                                                                                          \
+                                                                                                             \
+  template <typename Task>                                                                                   \
+  auto TaskListGenerator() {                                                                                 \
+    return GenTaskTuplesImpl<Task>(std::make_index_sequence<SizesParam.size()>{});                           \
   }
 
 }  // namespace ppc::util

tasks/example/all/include/ops_all.hpp

@@ -3,18 +3,16 @@
 #include <utility>
 #include <vector>
 
-#include "core/task/include/task.hpp"
+#include "example/common/include/common.hpp"
 
-namespace nesterov_a_test_task_all {
+namespace nesterov_a_test_task {
 
 void MatMul(const std::vector<int> &in_vec, int rc_size, std::vector<int> &out_vec);
 void MatMulTBB(const std::vector<int> &in_vec, int rc_size, std::vector<int> &out_vec);
 
-using InType = std::vector<int>;
-using OutType = std::vector<int>;
-
-class NesterovATestTaskALL : public ppc::core::Task<InType, OutType> {
+class NesterovATestTaskALL : public BaseTask {
  public:
+  static constexpr ppc::core::TypeOfTask GetTypeOfTask() { return ppc::core::TypeOfTask::kALL; }
   explicit NesterovATestTaskALL(const InType &in);
   bool ValidationImpl() override;
   bool PreProcessingImpl() override;
@@ -25,4 +23,4 @@ class NesterovATestTaskALL : public ppc::core::Task<InType, OutType> {
   int rc_size_{};
 };
 
-}  // namespace nesterov_a_test_task_all
+}  // namespace nesterov_a_test_task

tasks/example/all/src/ops_all.cpp

@@ -11,7 +11,7 @@
 #include "core/util/include/util.hpp"
 #include "oneapi/tbb/parallel_for.h"
 
-void nesterov_a_test_task_all::MatMul(const InType &in_vec, int rc_size, OutType &out_vec) {
+void nesterov_a_test_task::MatMul(const InType &in_vec, int rc_size, OutType &out_vec) {
   for (int i = 0; i < rc_size; ++i) {
     for (int j = 0; j < rc_size; ++j) {
       out_vec[(i * rc_size) + j] = 0;
@@ -22,26 +22,26 @@ void nesterov_a_test_task_all::MatMul(const InType &in_vec, int rc_size, OutType
   }
 }
 
-void nesterov_a_test_task_all::MatMulTBB(const InType &in_vec, int rc_size, OutType &out_vec) {
+void nesterov_a_test_task::MatMulTBB(const InType &in_vec, int rc_size, OutType &out_vec) {
   tbb::parallel_for(0, ppc::util::GetPPCNumThreads(), [&](int i) { MatMul(in_vec, rc_size - i, out_vec); });
   MatMul(in_vec, rc_size, out_vec);
 }
 
-nesterov_a_test_task_all::NesterovATestTaskALL::NesterovATestTaskALL(const InType &in) { GetInput() = in; }
+nesterov_a_test_task::NesterovATestTaskALL::NesterovATestTaskALL(const InType &in) { GetInput() = in; }
 
-bool nesterov_a_test_task_all::NesterovATestTaskALL::ValidationImpl() {
+bool nesterov_a_test_task::NesterovATestTaskALL::ValidationImpl() {
   auto sqrt_size = static_cast<int>(std::sqrt(GetInput().size()));
   return sqrt_size * sqrt_size == static_cast<int>(GetInput().size());
 }
 
-bool nesterov_a_test_task_all::NesterovATestTaskALL::PreProcessingImpl() {
+bool nesterov_a_test_task::NesterovATestTaskALL::PreProcessingImpl() {
   // Init value for input and output
   rc_size_ = static_cast<int>(std::sqrt(GetInput().size()));
   GetOutput() = OutType(GetInput().size(), 0);
   return true;
 }
 
-bool nesterov_a_test_task_all::NesterovATestTaskALL::RunImpl() {
+bool nesterov_a_test_task::NesterovATestTaskALL::RunImpl() {
   int rank = -1;
   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
   if (rank == 0) {
@@ -65,4 +65,4 @@ bool nesterov_a_test_task_all::NesterovATestTaskALL::RunImpl() {
   return true;
 }
 
-bool nesterov_a_test_task_all::NesterovATestTaskALL::PostProcessingImpl() { return true; }
+bool nesterov_a_test_task::NesterovATestTaskALL::PostProcessingImpl() { return true; }

tasks/example/common/include/common.hpp

@@ -0,0 +1,20 @@
+#pragma once
+
+#include <utility>
+#include <vector>
+
+#include "core/task/include/task.hpp"
+#include "core/util/include/test_util.hpp"
+#include "core/util/include/util.hpp"
+
+namespace nesterov_a_test_task {
+
+using InType = std::vector<int>;
+using OutType = std::vector<int>;
+using TestType = std::tuple<int, std::string>;
+
+using BaseTask = ppc::core::Task<InType, OutType>;
+using BasePerfTests = ppc::util::BaseRunPerfTests<InType, OutType>;
+using BaseFuncTests = ppc::util::BaseRunFuncTests<InType, OutType, TestType>;
+
+}  // namespace nesterov_a_test_task

tasks/example/mpi/include/ops_mpi.hpp

@@ -4,17 +4,16 @@
 #include <vector>
 
 #include "core/task/include/task.hpp"
+#include "example/common/include/common.hpp"
 
-namespace nesterov_a_test_task_mpi {
+namespace nesterov_a_test_task {
 
 void MultiplyRowMajor(const std::vector<int> &in, std::vector<int> &out, int rc_size);
 void MultiplyColumnMajor(const std::vector<int> &in, std::vector<int> &out, int rc_size);
 
-using InType = std::vector<int>;
-using OutType = std::vector<int>;
-
-class NesterovATestTaskMPI : public ppc::core::Task<InType, OutType> {
+class NesterovATestTaskMPI : public BaseTask {
  public:
+  static constexpr ppc::core::TypeOfTask GetTypeOfTask() { return ppc::core::TypeOfTask::kMPI; }
   explicit NesterovATestTaskMPI(const InType &in);
   bool ValidationImpl() override;
   bool PreProcessingImpl() override;
@@ -27,4 +26,4 @@ class NesterovATestTaskMPI : public ppc::core::Task<InType, OutType> {
   void MultiplyMatrixBasedOnRank();
 };
 
-}  // namespace nesterov_a_test_task_mpi
+}  // namespace nesterov_a_test_task

tasks/example/mpi/src/ops_mpi.cpp

@@ -6,7 +6,7 @@
 #include <cstddef>
 #include <vector>
 
-void nesterov_a_test_task_mpi::MultiplyRowMajor(const InType &in, OutType &out, int rc_size) {
+void nesterov_a_test_task::MultiplyRowMajor(const InType &in, OutType &out, int rc_size) {
   for (int i = 0; i < rc_size; ++i) {
     for (int j = 0; j < rc_size; ++j) {
       for (int k = 0; k < rc_size; ++k) {
@@ -16,7 +16,7 @@ void nesterov_a_test_task_mpi::MultiplyRowMajor(const InType &in, OutType &out,
   }
 }
 
-void nesterov_a_test_task_mpi::MultiplyColumnMajor(const InType &in, OutType &out, int rc_size) {
+void nesterov_a_test_task::MultiplyColumnMajor(const InType &in, OutType &out, int rc_size) {
   for (int j = 0; j < rc_size; ++j) {
     for (int k = 0; k < rc_size; ++k) {
       for (int i = 0; i < rc_size; ++i) {
@@ -26,28 +26,28 @@ void nesterov_a_test_task_mpi::MultiplyColumnMajor(const InType &in, OutType &ou
   }
 }
 
-nesterov_a_test_task_mpi::NesterovATestTaskMPI::NesterovATestTaskMPI(const InType &in) { GetInput() = in; }
+nesterov_a_test_task::NesterovATestTaskMPI::NesterovATestTaskMPI(const InType &in) { GetInput() = in; }
 
-bool nesterov_a_test_task_mpi::NesterovATestTaskMPI::ValidationImpl() {
+bool nesterov_a_test_task::NesterovATestTaskMPI::ValidationImpl() {
   auto sqrt_size = static_cast<int>(std::sqrt(GetInput().size()));
   return sqrt_size * sqrt_size == static_cast<int>(GetInput().size());
 }
 
-bool nesterov_a_test_task_mpi::NesterovATestTaskMPI::PreProcessingImpl() {
+bool nesterov_a_test_task::NesterovATestTaskMPI::PreProcessingImpl() {
   // Init value for input and output
   rc_size_ = static_cast<int>(std::sqrt(GetInput().size()));
   GetOutput() = OutType(GetInput().size(), 0);
   return true;
 }
 
-bool nesterov_a_test_task_mpi::NesterovATestTaskMPI::RunImpl() {
+bool nesterov_a_test_task::NesterovATestTaskMPI::RunImpl() {
   MultiplyMatrixBasedOnRank();
   return true;
 }
 
-bool nesterov_a_test_task_mpi::NesterovATestTaskMPI::PostProcessingImpl() { return true; }
+bool nesterov_a_test_task::NesterovATestTaskMPI::PostProcessingImpl() { return true; }
 
-void nesterov_a_test_task_mpi::NesterovATestTaskMPI::MultiplyMatrixBasedOnRank() {
+void nesterov_a_test_task::NesterovATestTaskMPI::MultiplyMatrixBasedOnRank() {
   int rank = -1;
   MPI_Comm_rank(MPI_COMM_WORLD, &rank);
 

tasks/example/omp/include/ops_omp.hpp

@@ -4,14 +4,13 @@
 #include <vector>
 
 #include "core/task/include/task.hpp"
+#include "example/common/include/common.hpp"
 
-namespace nesterov_a_test_task_omp {
+namespace nesterov_a_test_task {
 
-using InType = std::vector<int>;
-using OutType = std::vector<int>;
-
-class NesterovATestTaskOMP : public ppc::core::Task<InType, OutType> {
+class NesterovATestTaskOMP : public BaseTask {
  public:
+  static constexpr ppc::core::TypeOfTask GetTypeOfTask() { return ppc::core::TypeOfTask::kOMP; }
   explicit NesterovATestTaskOMP(const InType& in);
   bool ValidationImpl() override;
   bool PreProcessingImpl() override;
@@ -22,4 +21,4 @@ class NesterovATestTaskOMP : public ppc::core::Task<InType, OutType> {
   int rc_size_{};
 };
 
-}  // namespace nesterov_a_test_task_omp
+}  // namespace nesterov_a_test_task