Add revert list

.github/workflows/main.yml

@@ -65,6 +65,11 @@ jobs:
       env:
         CC: gcc-14
         CXX: g++-14
+    - name: Archive revert list
+      uses: actions/[email protected]
+      with:
+        name: revert-list
+        path: build/revert-list.txt
     - name: Build project
       run: |
         cmake --build build --parallel

tasks/CMakeLists.txt

@@ -50,7 +50,8 @@ foreach(TASK_TYPE ${LIST_OF_TASKS})
     SUBDIRLIST(subdirs ${PATH_TO_TASK})
     foreach(subd ${subdirs})
       if ("${subd}" MATCHES "_disabled$")
-        message(WARNING "   -- SKIPPED func and perf tests for ${PATH_TO_TASK}/${subd}")
+        get_filename_component(DIR_NAME ${PATH_TO_TASK} NAME)
+        list(APPEND LIST_OF_REVERTS "${DIR_NAME}_${subd}")
         continue()
       endif()
       get_filename_component(PROJECT_ID ${subd} NAME)
@@ -176,3 +177,11 @@ foreach(TASK_TYPE ${LIST_OF_TASKS})
     set(FUNC_TESTS_SOURCE_FILES "")
     set(PERF_TESTS_SOURCE_FILES "")
 endforeach()
+
+set(OUTPUT_FILE "${CMAKE_BINARY_DIR}/revert-list.txt")
+file(WRITE ${OUTPUT_FILE} "${CONTENT}")
+message(STATUS "revert list")
+foreach (dir_name ${LIST_OF_REVERTS})
+    message(STATUS "-- ${dir_name}")
+    file(APPEND ${OUTPUT_FILE} "${dir_name}\n")
+endforeach()

tasks/all/example/func_tests/func_mpi.cpp

@@ -5,7 +5,7 @@
 #include <random>
 #include <vector>
 
-#include "mpi/example/include/ops_mpi.hpp"
+#include "all/example/include/ops_mpi.hpp"
 
 namespace {
 std::vector<int> GetRandomVector(int sz) {

tasks/all/example/func_tests/func_omp.cpp

@@ -4,7 +4,7 @@
 #include <random>
 #include <vector>
 
-#include "omp/example/include/ops_omp.hpp"
+#include "all/example/include/ops_omp.hpp"
 
 namespace {
 std::vector<int> GetRandomVector(int sz) {

tasks/all/example/func_tests/func_seq.cpp

@@ -3,7 +3,7 @@
 #include <opencv2/opencv.hpp>
 #include <vector>
 
-#include "seq/example/include/ops_seq.hpp"
+#include "all/example/include/ops_seq.hpp"
 
 TEST(Sequential, Test_Sum_10) {
   const int count = 10;

tasks/all/example/func_tests/func_stl.cpp

@@ -5,7 +5,7 @@
 #include <thread>
 #include <vector>
 
-#include "stl/example/include/ops_stl.hpp"
+#include "all/example/include/ops_stl.hpp"
 
 namespace {
 std::vector<int> GetRandomVector(int sz) {

tasks/all/example/func_tests/func_tbb.cpp

@@ -4,7 +4,7 @@
 #include <random>
 #include <vector>
 
-#include "tbb/example/include/ops_tbb.hpp"
+#include "all/example/include/ops_tbb.hpp"
 
 namespace {
 std::vector<int> GetRandomVector(int sz) {

tasks/all/example/perf_tests/perf_omp.cpp

@@ -4,8 +4,8 @@
 #include <boost/mpi/communicator.hpp>
 #include <vector>
 
+#include "all/example/include/ops_omp.hpp"
 #include "core/perf/include/perf.hpp"
-#include "omp/example/include/ops_omp.hpp"
 
 TEST(all_example_perf_test, test_pipeline_run) {
   const int count = 100;

tasks/all/example/perf_tests/perf_tbb.cpp

@@ -4,8 +4,8 @@
 #include <boost/mpi/communicator.hpp>
 #include <vector>
 
+#include "all/example/include/ops_tbb.hpp"
 #include "core/perf/include/perf.hpp"
-#include "tbb/example/include/ops_tbb.hpp"
 
 TEST(all_example_perf_test, test_task_run) {
   const int count = 100;

tasks/all/example/src/ops_mpi.cpp

@@ -1,4 +1,4 @@
-#include "mpi/example/include/ops_mpi.hpp"
+#include "all/example/include/ops_mpi.hpp"
 
 #include <algorithm>
 #include <functional>

tasks/all/example/src/ops_omp.cpp

@@ -1,4 +1,4 @@
-#include "omp/example/include/ops_omp.hpp"
+#include "all/example/include/ops_omp.hpp"
 
 #include <omp.h>
 

tasks/all/example/src/ops_seq.cpp

@@ -1,4 +1,4 @@
-#include "seq/example/include/ops_seq.hpp"
+#include "all/example/include/ops_seq.hpp"
 
 #include <thread>
 

tasks/all/example/src/ops_stl.cpp

@@ -1,4 +1,4 @@
-#include "stl/example/include/ops_stl.hpp"
+#include "all/example/include/ops_stl.hpp"
 
 #include <future>
 #include <iostream>

tasks/all/example/src/ops_tbb.cpp

@@ -1,4 +1,4 @@
-#include "tbb/example/include/ops_tbb.hpp"
+#include "all/example/include/ops_tbb.hpp"
 
 #include <tbb/tbb.h>
 

tasks/seq/example_disabled/data/test.txt

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

tasks/seq/example_disabled/func_tests/main.cpp

@@ -0,0 +1,151 @@
+#include <gtest/gtest.h>
+
+#include <fstream>
+#include <vector>
+
+#include "seq/example/include/ops_seq.hpp"
+
+TEST(Sequential, Test_Sum_10) {
+  const int count = 10;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(Sequential, Test_Sum_20) {
+  const int count = 20;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(Sequential, Test_Sum_50) {
+  const int count = 50;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(Sequential, Test_Sum_70) {
+  const int count = 70;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(Sequential, Test_Sum_100) {
+  const int count = 100;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(Sequential, Test_Sum_100_From_File) {
+  std::string line;
+  std::ifstream test_file(ppc::core::GetAbsolutePath("seq/example/data/test.txt"));
+  if (test_file.is_open()) {
+    getline(test_file, line);
+  }
+  test_file.close();
+
+  const int count = std::stoi(line);
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq);
+  ASSERT_EQ(test_task_sequential.Validation(), true);
+  test_task_sequential.PreProcessing();
+  test_task_sequential.Run();
+  test_task_sequential.PostProcessing();
+  ASSERT_EQ(count, out[0]);
+}

tasks/seq/example_disabled/include/ops_seq.hpp

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "core/task/include/task.hpp"
+
+namespace nesterov_a_test_task_seq {
+
+class TestTaskSequential : public ppc::core::Task {
+ public:
+  explicit TestTaskSequential(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {}
+  bool PreProcessingImpl() override;
+  bool ValidationImpl() override;
+  bool RunImpl() override;
+  bool PostProcessingImpl() override;
+
+ private:
+  int input_{}, res_{};
+};
+
+}  // namespace nesterov_a_test_task_seq

tasks/seq/example_disabled/perf_tests/main.cpp

@@ -0,0 +1,80 @@
+#include <gtest/gtest.h>
+
+#include <vector>
+
+#include "core/perf/include/perf.hpp"
+#include "seq/example/include/ops_seq.hpp"
+
+TEST(sequential_example_perf_test, test_pipeline_run) {
+  const int count = 100;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  auto test_task_sequential = std::make_shared<nesterov_a_test_task_seq::TestTaskSequential>(task_data_seq);
+
+  // Create Perf attributes
+  auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
+  perf_attr->num_running = 10;
+  const auto t0 = std::chrono::high_resolution_clock::now();
+  perf_attr->current_timer = [&] {
+    auto current_time_point = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(current_time_point - t0).count();
+    return static_cast<double>(duration) * 1e-9;
+  };
+
+  // Create and init perf results
+  auto perf_results = std::make_shared<ppc::core::PerfResults>();
+
+  // Create Perf analyzer
+  auto perf_analyzer = std::make_shared<ppc::core::Perf>(test_task_sequential);
+  perf_analyzer->PipelineRun(perf_attr, perf_results);
+  ppc::core::Perf::PrintPerfStatistic(perf_results);
+  ASSERT_EQ(count, out[0]);
+}
+
+TEST(sequential_example_perf_test, test_task_run) {
+  const int count = 100;
+
+  // Create data
+  std::vector<int> in(1, count);
+  std::vector<int> out(1, 0);
+
+  // Create task_data
+  auto task_data_seq = std::make_shared<ppc::core::TaskData>();
+  task_data_seq->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
+  task_data_seq->inputs_count.emplace_back(in.size());
+  task_data_seq->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
+  task_data_seq->outputs_count.emplace_back(out.size());
+
+  // Create Task
+  auto test_task_sequential = std::make_shared<nesterov_a_test_task_seq::TestTaskSequential>(task_data_seq);
+
+  // Create Perf attributes
+  auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
+  perf_attr->num_running = 10;
+  const auto t0 = std::chrono::high_resolution_clock::now();
+  perf_attr->current_timer = [&] {
+    auto current_time_point = std::chrono::high_resolution_clock::now();
+    auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(current_time_point - t0).count();
+    return static_cast<double>(duration) * 1e-9;
+  };
+
+  // Create and init perf results
+  auto perf_results = std::make_shared<ppc::core::PerfResults>();
+
+  // Create Perf analyzer
+  auto perf_analyzer = std::make_shared<ppc::core::Perf>(test_task_sequential);
+  perf_analyzer->TaskRun(perf_attr, perf_results);
+  ppc::core::Perf::PrintPerfStatistic(perf_results);
+  ASSERT_EQ(count, out[0]);
+}