From bbedfed21759a79cc044f26bb230d5454281b514 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 17:51:49 +0200 Subject: [PATCH 01/22] change core part --- modules/core/perf/func_tests/perf_tests.cpp | 66 ++-------- modules/core/perf/func_tests/test_task.hpp | 28 +++-- modules/core/perf/include/perf.hpp | 2 +- modules/core/perf/src/perf.cpp | 2 +- modules/core/task/func_tests/task_tests.cpp | 128 +++++++------------- modules/core/task/func_tests/test_task.hpp | 29 +++-- modules/core/task/include/task.hpp | 31 ++--- modules/core/task/src/task.cpp | 12 +- 8 files changed, 105 insertions(+), 193 deletions(-) diff --git a/modules/core/perf/func_tests/perf_tests.cpp b/modules/core/perf/func_tests/perf_tests.cpp index fd93b60a5..8e01306ea 100644 --- a/modules/core/perf/func_tests/perf_tests.cpp +++ b/modules/core/perf/func_tests/perf_tests.cpp @@ -12,21 +12,12 @@ TEST(perf_tests, check_perf_pipeline) { // Create data std::vector in(2000, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - auto test_task = std::make_shared>(task_data); + auto test_task = std::make_shared>(in); // Create Perf attributes auto perf_attr = std::make_shared(); - perf_attr->num_running = 10; // Create and init perf results auto perf_results = std::make_shared(); @@ -38,27 +29,18 @@ TEST(perf_tests, check_perf_pipeline) { // Get perf statistic ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + EXPECT_EQ(test_task->Get(), in.size()); } TEST(perf_tests, check_perf_pipeline_float) { // Create data std::vector in(2000, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - auto test_task = std::make_shared>(task_data); + auto test_task = std::make_shared>(in); // Create Perf attributes auto perf_attr = std::make_shared(); - perf_attr->num_running = 10; // Create and init perf results auto perf_results = std::make_shared(); @@ -70,26 +52,20 @@ TEST(perf_tests, check_perf_pipeline_float) { // Get perf statistic ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + EXPECT_EQ(test_task->Get(), in.size()); } TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { // Create data std::vector in(128, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - auto test_task = std::make_shared>(task_data); + auto test_task = std::make_shared>(in); + // Create Perf attributes auto perf_attr = std::make_shared(); perf_attr->num_running = 1; + const auto t0 = std::chrono::high_resolution_clock::now(); perf_attr->current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); @@ -107,27 +83,18 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { // Get perf statistic ASSERT_ANY_THROW(ppc::core::Perf::PrintPerfStatistic(perf_results)); ASSERT_GE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + EXPECT_EQ(test_task->Get(), in.size()); } TEST(perf_tests, check_perf_task) { // Create data std::vector in(2000, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - auto test_task = std::make_shared>(task_data); + auto test_task = std::make_shared>(in); // Create Perf attributes auto perf_attr = std::make_shared(); - perf_attr->num_running = 10; // Create and init perf results auto perf_results = std::make_shared(); @@ -140,27 +107,18 @@ TEST(perf_tests, check_perf_task) { perf_results->type_of_running = ppc::core::PerfResults::kNone; ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + EXPECT_EQ(test_task->Get(), in.size()); } TEST(perf_tests, check_perf_task_float) { // Create data std::vector in(2000, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - auto test_task = std::make_shared>(task_data); + auto test_task = std::make_shared>(in); // Create Perf attributes auto perf_attr = std::make_shared(); - perf_attr->num_running = 10; // Create and init perf results auto perf_results = std::make_shared(); @@ -173,5 +131,5 @@ TEST(perf_tests, check_perf_task_float) { perf_results->type_of_running = ppc::core::PerfResults::kPipeline; ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + EXPECT_EQ(test_task->Get(), in.size()); } diff --git a/modules/core/perf/func_tests/test_task.hpp b/modules/core/perf/func_tests/test_task.hpp index 80325225e..e7fb299d8 100644 --- a/modules/core/perf/func_tests/test_task.hpp +++ b/modules/core/perf/func_tests/test_task.hpp @@ -12,35 +12,39 @@ namespace ppc::test::perf { template class TestTask : public ppc::core::Task { public: - explicit TestTask(const ppc::core::TaskDataPtr &task_data) : Task(task_data) {} + explicit TestTask(const std::vector& in) : ppc::core::Task(StateOfTesting::kFunc), input_(in) {} + + bool ValidationImpl() override { + return !input_.empty(); + } bool PreProcessingImpl() override { - input_ = reinterpret_cast(task_data->inputs[0]); - output_ = reinterpret_cast(task_data->outputs[0]); - output_[0] = 0; + output_ = 0; return true; } - bool ValidationImpl() override { return task_data->outputs_count[0] == 1; } - bool RunImpl() override { - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - output_[0] += input_[i]; + for (unsigned i = 0; i < input_.size(); i++) { + output_ += input_[i]; } return true; } - bool PostProcessingImpl() override { return true; } + bool PostProcessingImpl() override { + return true; + } + + T Get() { return output_; } private: - T *input_{}; - T *output_{}; + std::vector input_{}; + T output_; }; template class FakePerfTask : public TestTask { public: - explicit FakePerfTask(ppc::core::TaskDataPtr perf_task_data) : TestTask(perf_task_data) {} + explicit FakePerfTask(const std::vector& in) : TestTask(in) {} bool RunImpl() override { std::this_thread::sleep_for(std::chrono::seconds(11)); diff --git a/modules/core/perf/include/perf.hpp b/modules/core/perf/include/perf.hpp index 87227322f..42ce31ef7 100644 --- a/modules/core/perf/include/perf.hpp +++ b/modules/core/perf/include/perf.hpp @@ -10,7 +10,7 @@ namespace ppc::core { struct PerfAttr { // count of task's running - uint64_t num_running; + uint64_t num_running = 10; std::function current_timer = [&] { return 0.0; }; }; diff --git a/modules/core/perf/src/perf.cpp b/modules/core/perf/src/perf.cpp index b0244605a..db325c88b 100644 --- a/modules/core/perf/src/perf.cpp +++ b/modules/core/perf/src/perf.cpp @@ -16,7 +16,7 @@ ppc::core::Perf::Perf(const std::shared_ptr& task_ptr) { SetTask(task_ptr); } void ppc::core::Perf::SetTask(const std::shared_ptr& task_ptr) { - task_ptr->GetData()->state_of_testing = TaskData::StateOfTesting::kPerf; + task_ptr->GetStateOfTesting() = Task::StateOfTesting::kPerf; this->task_ = task_ptr; } diff --git a/modules/core/task/func_tests/task_tests.cpp b/modules/core/task/func_tests/task_tests.cpp index d68d2ad1a..7d1583888 100644 --- a/modules/core/task/func_tests/task_tests.cpp +++ b/modules/core/task/func_tests/task_tests.cpp @@ -6,174 +6,134 @@ #include #include "core/task/func_tests/test_task.hpp" -#include "core/task/include/task.hpp" TEST(task_tests, check_int32_t) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::task::TestTask test_task(task_data); + // Create and check Task + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); + + // Check Result + ASSERT_EQ(static_cast(test_task.Get()), in.size()); } TEST(task_tests, check_int32_t_slow) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - // Create TaskData - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::task::FakeSlowTask test_task(task_data); + // Create and check Task + ppc::test::task::FakeSlowTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); ASSERT_ANY_THROW(test_task.PostProcessing()); - ASSERT_EQ(static_cast(out[0]), in.size()); } TEST(task_tests, check_validate_func) { // Create data - std::vector in(20, 1); - std::vector out(2, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); + std::vector in; - // Create Task - ppc::test::task::TestTask test_task(task_data); + // Create and check Task + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); + + // Check Result ASSERT_EQ(is_valid, false); } TEST(task_tests, check_double) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::test::task::TestTask test_task(task_data); + // Create and check Task + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); test_task.PostProcessing(); - EXPECT_NEAR(out[0], static_cast(in.size()), 1e-6); + + // Check Result + EXPECT_NEAR(test_task.Get(), static_cast(in.size()), 1e-6); } TEST(task_tests, check_uint8_t) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - ppc::test::task::TestTask test_task(task_data); + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); + + // Check Result + ASSERT_EQ(static_cast(test_task.Get()), in.size()); } TEST(task_tests, check_int64_t) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - ppc::test::task::TestTask test_task(task_data); + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); + + // Check Result + ASSERT_EQ(static_cast(test_task.Get()), in.size()); } TEST(task_tests, check_float) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - ppc::test::task::TestTask test_task(task_data); + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); test_task.Run(); test_task.PostProcessing(); - EXPECT_NEAR(out[0], in.size(), 1e-3); + + // Check Result + EXPECT_NEAR(test_task.Get(), in.size(), 1e-3); } TEST(task_tests, check_wrong_order) { // Create data std::vector in(20, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); // Create Task - ppc::test::task::TestTask test_task(task_data); + ppc::test::task::TestTask test_task(in); bool is_valid = test_task.Validation(); ASSERT_EQ(is_valid, true); + + // Run Task test_task.PreProcessing(); ASSERT_ANY_THROW(test_task.PostProcessing()); } diff --git a/modules/core/task/func_tests/test_task.hpp b/modules/core/task/func_tests/test_task.hpp index 5a31990db..16455eb03 100644 --- a/modules/core/task/func_tests/test_task.hpp +++ b/modules/core/task/func_tests/test_task.hpp @@ -11,34 +11,39 @@ namespace ppc::test::task { template class TestTask : public ppc::core::Task { public: - explicit TestTask(const ppc::core::TaskDataPtr &task_data) : Task(task_data) {} + explicit TestTask(const std::vector& in) : ppc::core::Task(StateOfTesting::kFunc), input_(in) {} + + bool ValidationImpl() override { + return !input_.empty(); + } + bool PreProcessingImpl() override { - input_ = reinterpret_cast(task_data->inputs[0]); - output_ = reinterpret_cast(task_data->outputs[0]); - output_[0] = 0; + output_ = 0; return true; } - bool ValidationImpl() override { return task_data->outputs_count[0] == 1; } - bool RunImpl() override { - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - output_[0] += input_[i]; + for (unsigned i = 0; i < input_.size(); i++) { + output_ += input_[i]; } return true; } - bool PostProcessingImpl() override { return true; } + bool PostProcessingImpl() override { + return true; + } + + T Get() { return output_; } private: - T *input_{}; - T *output_{}; + std::vector input_{}; + T output_; }; template class FakeSlowTask : public TestTask { public: - explicit FakeSlowTask(ppc::core::TaskDataPtr perf_task_data) : TestTask(perf_task_data) {} + explicit FakeSlowTask(const std::vector& in) : TestTask(in) {} bool RunImpl() override { std::this_thread::sleep_for(std::chrono::seconds(2)); diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp index 7e31ada83..b2e65629a 100644 --- a/modules/core/task/include/task.hpp +++ b/modules/core/task/include/task.hpp @@ -8,24 +8,13 @@ namespace ppc::core { -struct TaskData { - std::vector inputs; - std::vector inputs_count; - std::vector outputs; - std::vector outputs_count; - enum StateOfTesting : uint8_t { kFunc, kPerf } state_of_testing; -}; - -using TaskDataPtr = std::shared_ptr; - // Memory of inputs and outputs need to be initialized before create object of // Task class class Task { public: - explicit Task(TaskDataPtr task_data); + enum StateOfTesting : uint8_t { kFunc, kPerf }; - // set input and output data - virtual void SetData(TaskDataPtr task_data) final; + explicit Task(StateOfTesting state_of_testing); // validation of data and validation of task attributes before running virtual bool Validation() final; @@ -33,34 +22,36 @@ class Task { // pre-processing of input data virtual bool PreProcessing() final; - // realization of current task + // realization of the current task virtual bool Run() final; // post-processing of output data virtual bool PostProcessing() final; - // get input and output data - [[nodiscard]] virtual TaskDataPtr GetData() const final; + // get state of testing + StateOfTesting& GetStateOfTesting() { + return state_of_testing_; + } virtual ~Task(); protected: virtual void InternalOrderTest(const std::string &str = __builtin_FUNCTION()) final; - TaskDataPtr task_data; - // implementation of "validation" function + // implementation of "Validation" function virtual bool ValidationImpl() = 0; // implementation of "PreProcessing" function virtual bool PreProcessingImpl() = 0; - // implementation of "run" function + // implementation of "Run" function virtual bool RunImpl() = 0; - // implementation of "post_processing" function + // implementation of "PostProcessing" function virtual bool PostProcessingImpl() = 0; private: + StateOfTesting state_of_testing_; std::vector functions_order_; std::vector right_functions_order_ = {"Validation", "PreProcessing", "Run", "PostProcessing"}; static constexpr double kMaxTestTime = 1.0; diff --git a/modules/core/task/src/task.cpp b/modules/core/task/src/task.cpp index 92b16d769..aaa98cb7c 100644 --- a/modules/core/task/src/task.cpp +++ b/modules/core/task/src/task.cpp @@ -10,16 +10,10 @@ #include #include -void ppc::core::Task::SetData(TaskDataPtr task_data_ptr) { - task_data_ptr->state_of_testing = TaskData::StateOfTesting::kFunc; +ppc::core::Task::Task(StateOfTesting state_of_testing) : state_of_testing_(state_of_testing) { functions_order_.clear(); - this->task_data = std::move(task_data_ptr); } -ppc::core::TaskDataPtr ppc::core::Task::GetData() const { return task_data; } - -ppc::core::Task::Task(TaskDataPtr task_data) { SetData(std::move(task_data)); } - bool ppc::core::Task::Validation() { InternalOrderTest(); return ValidationImpl(); @@ -56,11 +50,11 @@ void ppc::core::Task::InternalOrderTest(const std::string& str) { } } - if (str == "PreProcessing" && task_data->state_of_testing == TaskData::StateOfTesting::kFunc) { + if (str == "PreProcessing" && state_of_testing_ == StateOfTesting::kFunc) { tmp_time_point_ = std::chrono::high_resolution_clock::now(); } - if (str == "PostProcessing" && task_data->state_of_testing == TaskData::StateOfTesting::kFunc) { + if (str == "PostProcessing" && state_of_testing_ == StateOfTesting::kFunc) { auto end = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(end - tmp_time_point_).count(); auto current_time = static_cast(duration) * 1e-9; From da3b37f633dfaa1f9e79766a0fd3b49e3df6f4a7 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:08:13 +0200 Subject: [PATCH 02/22] change all dir --- modules/core/perf/func_tests/perf_tests.cpp | 2 -- modules/core/perf/func_tests/test_task.hpp | 2 +- modules/core/task/func_tests/test_task.hpp | 2 +- modules/core/task/include/task.hpp | 2 +- tasks/all/example/func_tests/func_all.cpp | 24 ++++--------------- tasks/all/example/include/ops_all.hpp | 5 +++- tasks/all/example/perf_tests/perf_all.cpp | 26 ++++----------------- tasks/all/example/src/ops_all.cpp | 15 +++--------- 8 files changed, 18 insertions(+), 60 deletions(-) diff --git a/modules/core/perf/func_tests/perf_tests.cpp b/modules/core/perf/func_tests/perf_tests.cpp index 8e01306ea..5870ca874 100644 --- a/modules/core/perf/func_tests/perf_tests.cpp +++ b/modules/core/perf/func_tests/perf_tests.cpp @@ -82,8 +82,6 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { // Get perf statistic ASSERT_ANY_THROW(ppc::core::Perf::PrintPerfStatistic(perf_results)); - ASSERT_GE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(test_task->Get(), in.size()); } TEST(perf_tests, check_perf_task) { diff --git a/modules/core/perf/func_tests/test_task.hpp b/modules/core/perf/func_tests/test_task.hpp index e7fb299d8..e83806194 100644 --- a/modules/core/perf/func_tests/test_task.hpp +++ b/modules/core/perf/func_tests/test_task.hpp @@ -12,7 +12,7 @@ namespace ppc::test::perf { template class TestTask : public ppc::core::Task { public: - explicit TestTask(const std::vector& in) : ppc::core::Task(StateOfTesting::kFunc), input_(in) {} + explicit TestTask(const std::vector& in) : input_(in) {} bool ValidationImpl() override { return !input_.empty(); diff --git a/modules/core/task/func_tests/test_task.hpp b/modules/core/task/func_tests/test_task.hpp index 16455eb03..0ef4f59b2 100644 --- a/modules/core/task/func_tests/test_task.hpp +++ b/modules/core/task/func_tests/test_task.hpp @@ -11,7 +11,7 @@ namespace ppc::test::task { template class TestTask : public ppc::core::Task { public: - explicit TestTask(const std::vector& in) : ppc::core::Task(StateOfTesting::kFunc), input_(in) {} + explicit TestTask(const std::vector& in) : input_(in) {} bool ValidationImpl() override { return !input_.empty(); diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp index b2e65629a..185792d32 100644 --- a/modules/core/task/include/task.hpp +++ b/modules/core/task/include/task.hpp @@ -14,7 +14,7 @@ class Task { public: enum StateOfTesting : uint8_t { kFunc, kPerf }; - explicit Task(StateOfTesting state_of_testing); + explicit Task(StateOfTesting state_of_testing = StateOfTesting::kFunc); // validation of data and validation of task attributes before running virtual bool Validation() final; diff --git a/tasks/all/example/func_tests/func_all.cpp b/tasks/all/example/func_tests/func_all.cpp index 4dc7fdf2e..e72581dd0 100644 --- a/tasks/all/example/func_tests/func_all.cpp +++ b/tasks/all/example/func_tests/func_all.cpp @@ -16,26 +16,18 @@ TEST(nesterov_a_test_task_all, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_all = std::make_shared(); - task_data_all->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_all->inputs_count.emplace_back(in.size()); - task_data_all->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_all->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_all::TestTaskALL test_task_all(task_data_all); + nesterov_a_test_task_all::TestTaskALL test_task_all(in); ASSERT_EQ(test_task_all.Validation(), true); test_task_all.PreProcessing(); test_task_all.Run(); test_task_all.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_all.Get()); } TEST(nesterov_a_test_task_all, test_matmul_from_pic) { @@ -53,24 +45,16 @@ TEST(nesterov_a_test_task_all, test_matmul_from_pic) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (int i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_all = std::make_shared(); - task_data_all->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_all->inputs_count.emplace_back(in.size()); - task_data_all->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_all->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_all::TestTaskALL test_task_all(task_data_all); + nesterov_a_test_task_all::TestTaskALL test_task_all(in); ASSERT_EQ(test_task_all.Validation(), true); test_task_all.PreProcessing(); test_task_all.Run(); test_task_all.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_all.Get()); } diff --git a/tasks/all/example/include/ops_all.hpp b/tasks/all/example/include/ops_all.hpp index 101339dec..9a6f0054e 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -9,11 +9,14 @@ namespace nesterov_a_test_task_all { class TestTaskALL : public ppc::core::Task { public: - explicit TestTaskALL(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} + explicit TestTaskALL(const std::vector& in) : input_(in) {} bool PreProcessingImpl() override; bool ValidationImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/all/example/perf_tests/perf_all.cpp b/tasks/all/example/perf_tests/perf_all.cpp index 5393ff606..2bee7c285 100644 --- a/tasks/all/example/perf_tests/perf_all.cpp +++ b/tasks/all/example/perf_tests/perf_all.cpp @@ -16,25 +16,16 @@ TEST(nesterov_a_test_task_all, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_all = std::make_shared(); - task_data_all->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_all->inputs_count.emplace_back(in.size()); - task_data_all->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_all->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_all = std::make_shared(task_data_all); + auto test_task_all = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -54,7 +45,7 @@ TEST(nesterov_a_test_task_all, test_pipeline_run) { ppc::core::Perf::PrintPerfStatistic(perf_results); } - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_all->Get()); } TEST(nesterov_a_test_task_all, test_task_run) { @@ -62,25 +53,16 @@ TEST(nesterov_a_test_task_all, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_all = std::make_shared(); - task_data_all->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_all->inputs_count.emplace_back(in.size()); - task_data_all->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_all->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_all = std::make_shared(task_data_all); + auto test_task_all = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -101,5 +83,5 @@ TEST(nesterov_a_test_task_all, test_task_run) { ppc::core::Perf::PrintPerfStatistic(perf_results); } - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_all->Get()); } diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index 84cec9a3e..2e42e2e25 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -27,20 +27,14 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v bool nesterov_a_test_task_all::TestTaskALL::PreProcessingImpl() { // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(rc_size_, 0); return true; } bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; + return input_.size() == output_.size(); } bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { @@ -75,8 +69,5 @@ bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { } bool nesterov_a_test_task_all::TestTaskALL::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From 16663116f4be50bec33206529224a8dfd9fa7117 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:21:56 +0200 Subject: [PATCH 03/22] change mpi dir --- tasks/all/example/include/ops_all.hpp | 2 +- tasks/all/example/src/ops_all.cpp | 12 ++++++------ tasks/mpi/example/func_tests/main.cpp | 24 ++++-------------------- tasks/mpi/example/include/ops_mpi.hpp | 7 +++++-- tasks/mpi/example/perf_tests/main.cpp | 26 ++++---------------------- tasks/mpi/example/src/ops_mpi.cpp | 23 +++++++---------------- 6 files changed, 27 insertions(+), 67 deletions(-) diff --git a/tasks/all/example/include/ops_all.hpp b/tasks/all/example/include/ops_all.hpp index 9a6f0054e..864642ade 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -10,8 +10,8 @@ namespace nesterov_a_test_task_all { class TestTaskALL : public ppc::core::Task { public: explicit TestTaskALL(const std::vector& in) : input_(in) {} - bool PreProcessingImpl() override; bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; std::vector Get() { diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index 2e42e2e25..c40728344 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -25,18 +25,18 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v } } // namespace +bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); +} + bool nesterov_a_test_task_all::TestTaskALL::PreProcessingImpl() { // Init value for input and output rc_size_ = static_cast(std::sqrt(input_.size())); - output_ = std::vector(rc_size_, 0); + output_ = std::vector(input_.size(), 0); return true; } -bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { - // Check equality of counts elements - return input_.size() == output_.size(); -} - bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); diff --git a/tasks/mpi/example/func_tests/main.cpp b/tasks/mpi/example/func_tests/main.cpp index 77f89c737..666b471eb 100644 --- a/tasks/mpi/example/func_tests/main.cpp +++ b/tasks/mpi/example/func_tests/main.cpp @@ -16,27 +16,19 @@ TEST(nesterov_a_test_task_mpi, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_mpi = std::make_shared(); - task_data_mpi->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_mpi->inputs_count.emplace_back(in.size()); - task_data_mpi->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_mpi->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(task_data_mpi); + nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(in); ASSERT_EQ(test_task_mpi.Validation(), true); test_task_mpi.PreProcessing(); test_task_mpi.Run(); test_task_mpi.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_mpi.Get()); } TEST(nesterov_a_test_task_mpi, test_matmul_100_from_file) { @@ -51,25 +43,17 @@ TEST(nesterov_a_test_task_mpi, test_matmul_100_from_file) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_mpi = std::make_shared(); - task_data_mpi->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_mpi->inputs_count.emplace_back(in.size()); - task_data_mpi->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_mpi->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(task_data_mpi); + nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(in); ASSERT_EQ(test_task_mpi.Validation(), true); test_task_mpi.PreProcessing(); test_task_mpi.Run(); test_task_mpi.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_mpi.Get()); } diff --git a/tasks/mpi/example/include/ops_mpi.hpp b/tasks/mpi/example/include/ops_mpi.hpp index 700f1be02..6804eeb50 100644 --- a/tasks/mpi/example/include/ops_mpi.hpp +++ b/tasks/mpi/example/include/ops_mpi.hpp @@ -9,11 +9,14 @@ namespace nesterov_a_test_task_mpi { class TestTaskMPI : public ppc::core::Task { public: - explicit TestTaskMPI(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} - bool PreProcessingImpl() override; + explicit TestTaskMPI(const std::vector& in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index 223909378..de866ff81 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -16,25 +16,16 @@ TEST(nesterov_a_test_task_mpi, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_mpi = std::make_shared(); - task_data_mpi->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_mpi->inputs_count.emplace_back(in.size()); - task_data_mpi->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_mpi->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_mpi = std::make_shared(task_data_mpi); + auto test_task_mpi = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -54,7 +45,7 @@ TEST(nesterov_a_test_task_mpi, test_pipeline_run) { ppc::core::Perf::PrintPerfStatistic(perf_results); } - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_mpi->Get()); } TEST(nesterov_a_test_task_mpi, test_task_run) { @@ -62,25 +53,16 @@ TEST(nesterov_a_test_task_mpi, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_mpi = std::make_shared(); - task_data_mpi->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_mpi->inputs_count.emplace_back(in.size()); - task_data_mpi->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_mpi->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_mpi = std::make_shared(task_data_mpi); + auto test_task_mpi = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -101,5 +83,5 @@ TEST(nesterov_a_test_task_mpi, test_task_run) { ppc::core::Perf::PrintPerfStatistic(perf_results); } - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_mpi->Get()); } diff --git a/tasks/mpi/example/src/ops_mpi.cpp b/tasks/mpi/example/src/ops_mpi.cpp index 331d278df..842669bec 100644 --- a/tasks/mpi/example/src/ops_mpi.cpp +++ b/tasks/mpi/example/src/ops_mpi.cpp @@ -6,24 +6,18 @@ #include #include +bool nesterov_a_test_task_mpi::TestTaskMPI::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); +} + bool nesterov_a_test_task_mpi::TestTaskMPI::PreProcessingImpl() { // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(input_.size(), 0); return true; } -bool nesterov_a_test_task_mpi::TestTaskMPI::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; -} - bool nesterov_a_test_task_mpi::TestTaskMPI::RunImpl() { MultiplyMatrixBasedOnRank(); return true; @@ -62,8 +56,5 @@ void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyColumnMajor() { } bool nesterov_a_test_task_mpi::TestTaskMPI::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From 85524063d15499c897b6ba235a2d506639b4aa3e Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:28:21 +0200 Subject: [PATCH 04/22] change omp dir --- tasks/omp/example/func_tests/main.cpp | 24 ++++-------------------- tasks/omp/example/include/ops_omp.hpp | 7 +++++-- tasks/omp/example/perf_tests/main.cpp | 26 ++++---------------------- tasks/omp/example/src/ops_omp.cpp | 24 +++++++----------------- 4 files changed, 20 insertions(+), 61 deletions(-) diff --git a/tasks/omp/example/func_tests/main.cpp b/tasks/omp/example/func_tests/main.cpp index 564a700f3..6ae487a97 100644 --- a/tasks/omp/example/func_tests/main.cpp +++ b/tasks/omp/example/func_tests/main.cpp @@ -16,26 +16,18 @@ TEST(nesterov_a_test_task_omp, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_omp = std::make_shared(); - task_data_omp->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_omp->inputs_count.emplace_back(in.size()); - task_data_omp->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_omp->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(task_data_omp); + nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(in); ASSERT_EQ(test_task_omp.Validation(), true); test_task_omp.PreProcessing(); test_task_omp.Run(); test_task_omp.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_omp.Get()); } TEST(nesterov_a_test_task_omp, test_matmul_100_from_file) { @@ -50,24 +42,16 @@ TEST(nesterov_a_test_task_omp, test_matmul_100_from_file) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_omp = std::make_shared(); - task_data_omp->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_omp->inputs_count.emplace_back(in.size()); - task_data_omp->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_omp->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(task_data_omp); + nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(in); ASSERT_EQ(test_task_omp.Validation(), true); test_task_omp.PreProcessing(); test_task_omp.Run(); test_task_omp.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_omp.Get()); } diff --git a/tasks/omp/example/include/ops_omp.hpp b/tasks/omp/example/include/ops_omp.hpp index fef03e988..4a90d4f59 100644 --- a/tasks/omp/example/include/ops_omp.hpp +++ b/tasks/omp/example/include/ops_omp.hpp @@ -9,11 +9,14 @@ namespace nesterov_a_test_task_omp { class TestTaskOpenMP : public ppc::core::Task { public: - explicit TestTaskOpenMP(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} - bool PreProcessingImpl() override; + explicit TestTaskOpenMP(const std::vector& in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/omp/example/perf_tests/main.cpp b/tasks/omp/example/perf_tests/main.cpp index a53cb7511..d63786d8a 100644 --- a/tasks/omp/example/perf_tests/main.cpp +++ b/tasks/omp/example/perf_tests/main.cpp @@ -15,25 +15,16 @@ TEST(nesterov_a_test_task_omp, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_omp = std::make_shared(); - task_data_omp->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_omp->inputs_count.emplace_back(in.size()); - task_data_omp->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_omp->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_omp = std::make_shared(task_data_omp); + auto test_task_omp = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -48,7 +39,7 @@ TEST(nesterov_a_test_task_omp, test_pipeline_run) { auto perf_analyzer = std::make_shared(test_task_omp); perf_analyzer->PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_omp->Get()); } TEST(nesterov_a_test_task_omp, test_task_run) { @@ -56,25 +47,16 @@ TEST(nesterov_a_test_task_omp, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_omp = std::make_shared(); - task_data_omp->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_omp->inputs_count.emplace_back(in.size()); - task_data_omp->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_omp->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_omp = std::make_shared(task_data_omp); + auto test_task_omp = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -89,5 +71,5 @@ TEST(nesterov_a_test_task_omp, test_task_run) { auto perf_analyzer = std::make_shared(test_task_omp); perf_analyzer->TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_omp->Get()); } diff --git a/tasks/omp/example/src/ops_omp.cpp b/tasks/omp/example/src/ops_omp.cpp index 7db50f2d5..d0a913bbc 100644 --- a/tasks/omp/example/src/ops_omp.cpp +++ b/tasks/omp/example/src/ops_omp.cpp @@ -4,22 +4,15 @@ #include #include -bool nesterov_a_test_task_omp::TestTaskOpenMP::PreProcessingImpl() { - // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); - return true; +bool nesterov_a_test_task_omp::TestTaskOpenMP::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); } -bool nesterov_a_test_task_omp::TestTaskOpenMP::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; +bool nesterov_a_test_task_omp::TestTaskOpenMP::PreProcessingImpl() { + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(input_.size(), 0); + return true; } bool nesterov_a_test_task_omp::TestTaskOpenMP::RunImpl() { @@ -42,8 +35,5 @@ bool nesterov_a_test_task_omp::TestTaskOpenMP::RunImpl() { } bool nesterov_a_test_task_omp::TestTaskOpenMP::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From dc240b74ff46b90fe8a5c0d873f81b2cafc46fd5 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:33:53 +0200 Subject: [PATCH 05/22] change seq dir --- tasks/seq/example/func_tests/main.cpp | 24 ++++-------------------- tasks/seq/example/include/ops_seq.hpp | 7 +++++-- tasks/seq/example/perf_tests/main.cpp | 26 ++++---------------------- tasks/seq/example/src/ops_seq.cpp | 24 +++++++----------------- 4 files changed, 20 insertions(+), 61 deletions(-) diff --git a/tasks/seq/example/func_tests/main.cpp b/tasks/seq/example/func_tests/main.cpp index 54ddb2c42..066d057c0 100644 --- a/tasks/seq/example/func_tests/main.cpp +++ b/tasks/seq/example/func_tests/main.cpp @@ -16,26 +16,18 @@ TEST(nesterov_a_test_task_seq, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(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); + nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(in); ASSERT_EQ(test_task_sequential.Validation(), true); test_task_sequential.PreProcessing(); test_task_sequential.Run(); test_task_sequential.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_sequential.Get()); } TEST(nesterov_a_test_task_seq, test_matmul_100_from_file) { @@ -50,24 +42,16 @@ TEST(nesterov_a_test_task_seq, test_matmul_100_from_file) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(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); + nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(in); ASSERT_EQ(test_task_sequential.Validation(), true); test_task_sequential.PreProcessing(); test_task_sequential.Run(); test_task_sequential.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_sequential.Get()); } diff --git a/tasks/seq/example/include/ops_seq.hpp b/tasks/seq/example/include/ops_seq.hpp index 728bde58d..d720c96ea 100644 --- a/tasks/seq/example/include/ops_seq.hpp +++ b/tasks/seq/example/include/ops_seq.hpp @@ -9,11 +9,14 @@ 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; + explicit TestTaskSequential(const std::vector& in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/seq/example/perf_tests/main.cpp b/tasks/seq/example/perf_tests/main.cpp index 3dfe18048..e04d44572 100644 --- a/tasks/seq/example/perf_tests/main.cpp +++ b/tasks/seq/example/perf_tests/main.cpp @@ -15,25 +15,16 @@ TEST(nesterov_a_test_task_seq, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_seq->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_sequential = std::make_shared(task_data_seq); + auto test_task_sequential = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -48,7 +39,7 @@ TEST(nesterov_a_test_task_seq, test_pipeline_run) { auto perf_analyzer = std::make_shared(test_task_sequential); perf_analyzer->PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_sequential->Get()); } TEST(nesterov_a_test_task_seq, test_task_run) { @@ -56,25 +47,16 @@ TEST(nesterov_a_test_task_seq, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_seq->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_sequential = std::make_shared(task_data_seq); + auto test_task_sequential = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -89,5 +71,5 @@ TEST(nesterov_a_test_task_seq, test_task_run) { auto perf_analyzer = std::make_shared(test_task_sequential); perf_analyzer->TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_sequential->Get()); } diff --git a/tasks/seq/example/src/ops_seq.cpp b/tasks/seq/example/src/ops_seq.cpp index 23639db05..2ee537e55 100644 --- a/tasks/seq/example/src/ops_seq.cpp +++ b/tasks/seq/example/src/ops_seq.cpp @@ -4,22 +4,15 @@ #include #include -bool nesterov_a_test_task_seq::TestTaskSequential::PreProcessingImpl() { - // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); - return true; +bool nesterov_a_test_task_seq::TestTaskSequential::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); } -bool nesterov_a_test_task_seq::TestTaskSequential::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; +bool nesterov_a_test_task_seq::TestTaskSequential::PreProcessingImpl() { + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(input_.size(), 0); + return true; } bool nesterov_a_test_task_seq::TestTaskSequential::RunImpl() { @@ -35,8 +28,5 @@ bool nesterov_a_test_task_seq::TestTaskSequential::RunImpl() { } bool nesterov_a_test_task_seq::TestTaskSequential::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From a7ec8974db1a5b5a24a94620d2dcbe98f602e95d Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:40:03 +0200 Subject: [PATCH 06/22] change stl dir --- modules/ref/CMakeLists.txt | 53 ----- .../func_tests/ref_tests.cpp | 136 ------------ .../include/ref_task.hpp | 51 ----- .../func_tests/ref_tests.cpp | 184 ---------------- .../include/ref_task.hpp | 60 ----- .../func_tests/ref_tests.cpp | 184 ---------------- .../include/ref_task.hpp | 60 ----- .../func_tests/ref_tests.cpp | 205 ------------------ .../include/ref_task.hpp | 68 ------ .../func_tests/ref_tests.cpp | 205 ------------------ .../include/ref_task.hpp | 68 ------ .../func_tests/ref_tests.cpp | 147 ------------- .../include/ref_task.hpp | 58 ----- .../func_tests/ref_tests.cpp | 147 ------------- .../include/ref_task.hpp | 58 ----- .../func_tests/ref_tests.cpp | 124 ----------- .../include/ref_task.hpp | 47 ---- .../func_tests/ref_tests.cpp | 196 ----------------- .../include/ref_task.hpp | 60 ----- .../func_tests/ref_tests.cpp | 189 ---------------- .../vector_dot_product/include/ref_task.hpp | 55 ----- tasks/stl/example/func_tests/main.cpp | 24 +- tasks/stl/example/include/ops_stl.hpp | 7 +- tasks/stl/example/perf_tests/main.cpp | 26 +-- tasks/stl/example/src/ops_stl.cpp | 24 +- 25 files changed, 20 insertions(+), 2416 deletions(-) delete mode 100644 modules/ref/CMakeLists.txt delete mode 100644 modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/average_of_vector_elements/include/ref_task.hpp delete mode 100644 modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/max_of_vector_elements/include/ref_task.hpp delete mode 100644 modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/min_of_vector_elements/include/ref_task.hpp delete mode 100644 modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/most_different_neighbor_elements/include/ref_task.hpp delete mode 100644 modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/nearest_neighbor_elements/include/ref_task.hpp delete mode 100644 modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp delete mode 100644 modules/ref/num_of_alternations_signs/include/ref_task.hpp delete mode 100644 modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp delete mode 100644 modules/ref/num_of_orderly_violations/include/ref_task.hpp delete mode 100644 modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp delete mode 100644 modules/ref/sum_of_vector_elements/include/ref_task.hpp delete mode 100644 modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp delete mode 100644 modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp delete mode 100644 modules/ref/vector_dot_product/func_tests/ref_tests.cpp delete mode 100644 modules/ref/vector_dot_product/include/ref_task.hpp diff --git a/modules/ref/CMakeLists.txt b/modules/ref/CMakeLists.txt deleted file mode 100644 index 3887641b1..000000000 --- a/modules/ref/CMakeLists.txt +++ /dev/null @@ -1,53 +0,0 @@ -get_filename_component(MODULE_NAME ${CMAKE_CURRENT_SOURCE_DIR} NAME) -message(STATUS "${MODULE_NAME} tasks") -set(exec_func_tests "${MODULE_NAME}_func_tests") -set(exec_func_lib "${MODULE_NAME}_module_lib") -set(project_suffix "_${MODULE_NAME}") - -SUBDIRLIST(subdirs ${CMAKE_CURRENT_SOURCE_DIR}) - -foreach(subd ${subdirs}) - get_filename_component(PROJECT_ID ${subd} NAME) - set(PATH_PREFIX "${CMAKE_CURRENT_SOURCE_DIR}/${subd}") - set(PROJECT_ID "${PROJECT_ID}${project_suffix}") - message(STATUS "-- " ${PROJECT_ID}) - - file(GLOB_RECURSE TMP_LIB_SOURCE_FILES ${PATH_PREFIX}/include/* ${PATH_PREFIX}/src/*) - list(APPEND LIB_SOURCE_FILES ${TMP_LIB_SOURCE_FILES}) - - file(GLOB TMP_SRC_RES ${PATH_PREFIX}/src/*) - list(APPEND SRC_RES ${TMP_SRC_RES}) - - file(GLOB_RECURSE TMP_FUNC_TESTS_SOURCE_FILES ${PATH_PREFIX}/func_tests/*) - list(APPEND FUNC_TESTS_SOURCE_FILES ${TMP_FUNC_TESTS_SOURCE_FILES}) -endforeach() - -project(${exec_func_lib}) -list(LENGTH SRC_RES RES_LEN) -if(RES_LEN EQUAL 0) - add_library(${exec_func_lib} INTERFACE ${LIB_SOURCE_FILES}) -else() - add_library(${exec_func_lib} STATIC ${LIB_SOURCE_FILES}) -endif() -set_target_properties(${exec_func_lib} PROPERTIES LINKER_LANGUAGE CXX) - -add_executable(${exec_func_tests} ${FUNC_TESTS_SOURCE_FILES}) -target_link_libraries(${exec_func_tests} PUBLIC core_module_lib) - -add_dependencies(${exec_func_tests} ppc_googletest) -target_link_directories(${exec_func_tests} PUBLIC ${CMAKE_BINARY_DIR}/ppc_googletest/install/lib) -target_link_libraries(${exec_func_tests} PUBLIC gtest gtest_main) - -target_link_libraries(${exec_func_tests} PUBLIC ${exec_func_lib}) - -enable_testing() -add_test(NAME ${exec_func_tests} COMMAND ${exec_func_tests}) - -# Installation rules -install(TARGETS ${exec_func_lib} - ARCHIVE DESTINATION lib - LIBRARY DESTINATION lib - RUNTIME DESTINATION bin) - -install(TARGETS ${exec_func_tests} - RUNTIME DESTINATION bin) diff --git a/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp deleted file mode 100644 index ac173edc9..000000000 --- a/modules/ref/average_of_vector_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,136 +0,0 @@ -#include - -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/average_of_vector_elements/include/ref_task.hpp" - -TEST(average_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1.0, 1e-5); -} - -TEST(average_of_vector_elements, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(average_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1.123); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1.123, 1e-5); -} - -TEST(average_of_vector_elements, check_uint8_t) { - // Create data - std::vector in(255, 2); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 2.0, 1e-5); -} - -TEST(average_of_vector_elements, check_int64_t) { - // Create data - std::vector in(75836, 3); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 3.0, 1e-5); -} - -TEST(average_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1.5F); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1.5, 1e-5); -} diff --git a/modules/ref/average_of_vector_elements/include/ref_task.hpp b/modules/ref/average_of_vector_elements/include/ref_task.hpp deleted file mode 100644 index 92ef54f06..000000000 --- a/modules/ref/average_of_vector_elements/include/ref_task.hpp +++ /dev/null @@ -1,51 +0,0 @@ -#ifndef MODULES_REFERENCE_AVERAGE_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ -#define MODULES_REFERENCE_AVERAGE_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class AverageOfVectorElements : public ppc::core::Task { - public: - explicit AverageOfVectorElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - average_ = 0.0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 1; - } - - bool RunImpl() override { - average_ = static_cast(std::accumulate(input_.begin(), input_.end(), 0.0)); - average_ /= static_cast(task_data->inputs_count[0]); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = average_; - return true; - } - - private: - std::vector input_; - OutType average_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_AVERAGE_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ diff --git a/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp deleted file mode 100644 index af1b4fd25..000000000 --- a/modules/ref/max_of_vector_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,184 +0,0 @@ -#include - -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/max_of_vector_elements/include/ref_task.hpp" - -TEST(max_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[328] = 10; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 10); - ASSERT_EQ(out_index[0], 328ULL); -} - -TEST(max_of_vector_elements, check_validate_func_1) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(max_of_vector_elements, check_validate_func_2) { - // Create data - std::vector in(125, 1); - std::vector out(1, 0); - std::vector out_index(2, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(max_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[2] = 1.0001; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1.0001, 1e-6); - ASSERT_EQ(out_index[0], 2ULL); -} - -TEST(max_of_vector_elements, check_uint8_t) { - // Create data - std::vector in(255, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 1); - ASSERT_EQ(out_index[0], 0ULL); -} - -TEST(max_of_vector_elements, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[345] = 256; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 256LL); - ASSERT_EQ(out_index[0], 345ULL); -} - -TEST(max_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1.F); - std::vector out(1, 0.F); - std::vector out_index(1, 0); - in[0] = 1.01F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1.01F, 1e-6F); - ASSERT_EQ(out_index[0], 0ULL); -} diff --git a/modules/ref/max_of_vector_elements/include/ref_task.hpp b/modules/ref/max_of_vector_elements/include/ref_task.hpp deleted file mode 100644 index 2a29fb437..000000000 --- a/modules/ref/max_of_vector_elements/include/ref_task.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef MODULES_REFERENCE_MAX_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ -#define MODULES_REFERENCE_MAX_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class MaxOfVectorElements : public ppc::core::Task { - public: - explicit MaxOfVectorElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - max_ = 0.0; - max_index_ = 0; - return true; - } - - bool ValidationImpl() override { - bool is_count_values_correct = false; - bool is_count_indexes_correct = false; - // Check count elements of output - is_count_values_correct = task_data->outputs_count[0] == 1; - is_count_indexes_correct = task_data->outputs_count[1] == 1; - - return is_count_values_correct && is_count_indexes_correct; - } - - bool RunImpl() override { - auto result = std::max_element(input_.begin(), input_.end()); - max_ = static_cast(*result); - max_index_ = static_cast(std::distance(input_.begin(), result)); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = max_; - reinterpret_cast(task_data->outputs[1])[0] = max_index_; - return true; - } - - private: - std::vector input_; - InOutType max_; - IndexType max_index_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_MAX_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ diff --git a/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp deleted file mode 100644 index 59b25f648..000000000 --- a/modules/ref/min_of_vector_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,184 +0,0 @@ -#include - -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/min_of_vector_elements/include/ref_task.hpp" - -TEST(min_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[328] = -10; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], -10); - ASSERT_EQ(out_index[0], 328ULL); -} - -TEST(min_of_vector_elements, check_validate_func_1) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(min_of_vector_elements, check_validate_func_2) { - // Create data - std::vector in(125, 1); - std::vector out(1, 0); - std::vector out_index(2, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(min_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[2] = -1.0001; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], -1.0001, 1e-6); - ASSERT_EQ(out_index[0], 2ULL); -} - -TEST(min_of_vector_elements, check_uint8_t) { - // Create data - std::vector in(255, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 1, 1e-6); - ASSERT_EQ(out_index[0], 0ULL); -} - -TEST(min_of_vector_elements, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[345] = -256; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], -256, 1e-6); - ASSERT_EQ(out_index[0], 345ULL); -} - -TEST(min_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1.F); - std::vector out(1, 0.F); - std::vector out_index(1, 0); - in[0] = -1.01F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], -1.01F, 1e-6F); - ASSERT_EQ(out_index[0], 0ULL); -} diff --git a/modules/ref/min_of_vector_elements/include/ref_task.hpp b/modules/ref/min_of_vector_elements/include/ref_task.hpp deleted file mode 100644 index 6c2752c4d..000000000 --- a/modules/ref/min_of_vector_elements/include/ref_task.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef MODULES_REFERENCE_MIN_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ -#define MODULES_REFERENCE_MIN_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class MinOfVectorElements : public ppc::core::Task { - public: - explicit MinOfVectorElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - min_ = 0.0; - min_index_ = 0; - return true; - } - - bool ValidationImpl() override { - bool is_count_values_correct = false; - bool is_count_indexes_correct = false; - // Check count elements of output - is_count_values_correct = task_data->outputs_count[0] == 1; - is_count_indexes_correct = task_data->outputs_count[1] == 1; - - return is_count_values_correct && is_count_indexes_correct; - } - - bool RunImpl() override { - auto result = std::min_element(input_.begin(), input_.end()); - min_ = static_cast(*result); - min_index_ = static_cast(std::distance(input_.begin(), result)); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = min_; - reinterpret_cast(task_data->outputs[1])[0] = min_index_; - return true; - } - - private: - std::vector input_; - InOutType min_; - IndexType min_index_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_MIN_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ diff --git a/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp b/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp deleted file mode 100644 index af25da2b3..000000000 --- a/modules/ref/most_different_neighbor_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,205 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/most_different_neighbor_elements/include/ref_task.hpp" - -TEST(most_different_neighbor_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] = static_cast(2 * i); - } - in[234] = 0; - in[235] = 4000; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 0); - EXPECT_EQ(out[1], 4000); - EXPECT_EQ(out_index[0], 234ULL); - EXPECT_EQ(out_index[1], 235ULL); -} - -TEST(most_different_neighbor_elements, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, false); -} - -TEST(most_different_neighbor_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] = static_cast(i); - } - in[189] = -1000.1; - in[190] = 9000.9; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], -1000.1, 1e-6); - EXPECT_NEAR(out[1], 9000.9, 1e-6); - EXPECT_EQ(out_index[0], 189ULL); - EXPECT_EQ(out_index[1], 190ULL); -} - -TEST(most_different_neighbor_elements, check_int8_t) { - // Create data - std::vector in(250, -1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 2 == 0) { - in[i] = -50; - } else { - in[i] = 50; - } - } - in[5] = 56; - in[6] = -56; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 56); - EXPECT_EQ(out[1], -56); - EXPECT_EQ(out_index[0], 5ULL); - EXPECT_EQ(out_index[1], 6ULL); -} - -TEST(most_different_neighbor_elements, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 3 == 0) { - in[i] = 10; - } else if (i % 3 == 1) { - in[i] = 30; - } else { // (i % 3 == 2) - in[i] = 70; - } - } - in[20] = -1000; - in[21] = 1119; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], -1000); - EXPECT_EQ(out[1], 1119); - EXPECT_EQ(out_index[0], 20ULL); - EXPECT_EQ(out_index[1], 21ULL); -} - -TEST(most_different_neighbor_elements, check_float) { - // Create data - std::vector in(20, 1.F); - std::vector out(2, 0.F); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] += (static_cast(i) + 1.F) * 2.5F; - } - in[0] = 110.001F; - in[1] = -990.0025F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 110.001F, 1e-4F); - EXPECT_NEAR(out[1], -990.0025F, 1e-4F); - EXPECT_EQ(out_index[0], 0ULL); - EXPECT_EQ(out_index[1], 1ULL); -} diff --git a/modules/ref/most_different_neighbor_elements/include/ref_task.hpp b/modules/ref/most_different_neighbor_elements/include/ref_task.hpp deleted file mode 100644 index 04afd28a5..000000000 --- a/modules/ref/most_different_neighbor_elements/include/ref_task.hpp +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef MODULES_REFERENCE_MOST_DIFFERENT_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ -#define MODULES_REFERENCE_MOST_DIFFERENT_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class MostDifferentNeighborElements : public ppc::core::Task { - public: - explicit MostDifferentNeighborElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - l_elem_ = r_elem_ = 0; - l_elem_index_ = r_elem_index_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 2 && task_data->outputs_count[1] == 2; - } - - bool RunImpl() override { - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); - - auto temp_res = std::vector(input_.size()); - std::transform(input_.begin(), input_.end(), rotate_in.begin(), temp_res.begin(), - [](InOutType x, InOutType y) { return std::abs(x - y); }); - - auto result = std::max_element(temp_res.begin(), temp_res.end() - 1); - l_elem_index_ = static_cast(std::distance(temp_res.begin(), result)); - l_elem_ = input_[l_elem_index_]; - - r_elem_index_ = l_elem_index_ + 1; - r_elem_ = input_[r_elem_index_]; - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = l_elem_; - reinterpret_cast(task_data->outputs[0])[1] = r_elem_; - reinterpret_cast(task_data->outputs[1])[0] = l_elem_index_; - reinterpret_cast(task_data->outputs[1])[1] = r_elem_index_; - return true; - } - - private: - std::vector input_; - InOutType l_elem_, r_elem_; - IndexType l_elem_index_, r_elem_index_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_MOST_DIFFERENT_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ diff --git a/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp b/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp deleted file mode 100644 index f6d88ebc2..000000000 --- a/modules/ref/nearest_neighbor_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,205 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/nearest_neighbor_elements/include/ref_task.hpp" - -TEST(nearest_neighbor_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] = static_cast(2 * i); - } - in[234] = 0; - in[235] = 1; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 0); - EXPECT_EQ(out[1], 1); - EXPECT_EQ(out_index[0], 234ULL); - EXPECT_EQ(out_index[1], 235ULL); -} - -TEST(nearest_neighbor_elements, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - std::vector out_index(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, false); -} - -TEST(nearest_neighbor_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] = static_cast(2 * i); - } - in[189] = 0.1; - in[190] = 0.9; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 0.1, 1e-6); - EXPECT_NEAR(out[1], 0.9, 1e-6); - EXPECT_EQ(out_index[0], 189ULL); - EXPECT_EQ(out_index[1], 190ULL); -} - -TEST(nearest_neighbor_elements, check_int8_t) { - // Create data - std::vector in(250, -1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 2 == 0) { - in[i] = -50; - } else { - in[i] = 50; - } - } - in[5] = 8; - in[6] = -8; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], 8); - EXPECT_EQ(out[1], -8); - EXPECT_EQ(out_index[0], 5ULL); - EXPECT_EQ(out_index[1], 6ULL); -} - -TEST(nearest_neighbor_elements, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 3 == 0) { - in[i] = 10; - } else if (i % 3 == 1) { - in[i] = 30; - } else { // (i % 3 == 2) - in[i] = 70; - } - } - in[20] = -100; - in[21] = -119; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_EQ(out[0], -100); - EXPECT_EQ(out[1], -119); - EXPECT_EQ(out_index[0], 20ULL); - EXPECT_EQ(out_index[1], 21ULL); -} - -TEST(nearest_neighbor_elements, check_float) { - // Create data - std::vector in(20, 1.F); - std::vector out(2, 0.F); - std::vector out_index(2, 0); - for (size_t i = 0; i < in.size(); i++) { - in[i] += static_cast(i + 1) * 2.5F; - } - in[0] = 0.001F; - in[1] = 0.0025F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - task_data->outputs.emplace_back(reinterpret_cast(out_index.data())); - task_data->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements test_task(task_data); - bool is_valid = test_task.Validation(); - EXPECT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], 0.001F, 1e-4F); - EXPECT_NEAR(out[1], 0.0025F, 1e-4F); - EXPECT_EQ(out_index[0], 0ULL); - EXPECT_EQ(out_index[1], 1ULL); -} diff --git a/modules/ref/nearest_neighbor_elements/include/ref_task.hpp b/modules/ref/nearest_neighbor_elements/include/ref_task.hpp deleted file mode 100644 index 17a28ea89..000000000 --- a/modules/ref/nearest_neighbor_elements/include/ref_task.hpp +++ /dev/null @@ -1,68 +0,0 @@ -#ifndef MODULES_REFERENCE_NEAREST_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ -#define MODULES_REFERENCE_NEAREST_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class NearestNeighborElements : public ppc::core::Task { - public: - explicit NearestNeighborElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - l_elem_ = r_elem_ = 0; - l_elem_index_ = r_elem_index_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 2 && task_data->outputs_count[1] == 2; - } - - bool RunImpl() override { - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); - - auto temp_res = std::vector(input_.size()); - std::transform(input_.begin(), input_.end(), rotate_in.begin(), temp_res.begin(), - [](InOutType x, InOutType y) { return std::abs(x - y); }); - - auto result = std::min_element(temp_res.begin(), temp_res.end() - 1); - l_elem_index_ = static_cast(std::distance(temp_res.begin(), result)); - l_elem_ = input_[l_elem_index_]; - - r_elem_index_ = l_elem_index_ + 1; - r_elem_ = input_[r_elem_index_]; - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = l_elem_; - reinterpret_cast(task_data->outputs[0])[1] = r_elem_; - reinterpret_cast(task_data->outputs[1])[0] = l_elem_index_; - reinterpret_cast(task_data->outputs[1])[1] = r_elem_index_; - return true; - } - - private: - std::vector input_; - InOutType l_elem_, r_elem_; - IndexType l_elem_index_, r_elem_index_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_NEAREST_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ diff --git a/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp b/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp deleted file mode 100644 index ad311c4d7..000000000 --- a/modules/ref/num_of_alternations_signs/func_tests/ref_tests.cpp +++ /dev/null @@ -1,147 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/num_of_alternations_signs/include/ref_task.hpp" - -TEST(num_of_alternations_signs, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 2 == 0) { - in[i] *= -1; - } - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], in.size() - 1); -} - -TEST(num_of_alternations_signs, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(num_of_alternations_signs, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - in[1] = -1; - in[200] = -1; - in[456] = -1; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 6ULL); -} - -TEST(num_of_alternations_signs, check_int8_t) { - // Create data - std::vector in(255, -1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 0ULL); -} - -TEST(num_of_alternations_signs, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - for (size_t i = 500; i < in.size() - 600; i++) { - in[i] *= -1; - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 2ULL); -} - -TEST(num_of_alternations_signs, check_float) { - // Create data - std::vector in(3, 1.F); - std::vector out(1, 0); - in[1] = -1.0001F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 2ULL); -} diff --git a/modules/ref/num_of_alternations_signs/include/ref_task.hpp b/modules/ref/num_of_alternations_signs/include/ref_task.hpp deleted file mode 100644 index 0599a6a06..000000000 --- a/modules/ref/num_of_alternations_signs/include/ref_task.hpp +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef MODULES_REFERENCE_NUM_OF_ALTERNATIONS_SIGNS_REF_TASK_HPP_ -#define MODULES_REFERENCE_NUM_OF_ALTERNATIONS_SIGNS_REF_TASK_HPP_ - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class NumOfAlternationsSigns : public ppc::core::Task { - public: - explicit NumOfAlternationsSigns(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - num_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 1; - } - - bool RunImpl() override { - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); - - auto temp_res = input_; - std::transform(input_.begin(), input_.end(), rotate_in.begin(), temp_res.begin(), std::multiplies<>()); - - num_ = std::count_if(temp_res.begin(), temp_res.end() - 1, [](InOutType elem) { return elem < 0; }); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = num_; - return true; - } - - private: - std::vector input_; - CountType num_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_NUM_OF_ALTERNATIONS_SIGNS_REF_TASK_HPP_ diff --git a/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp b/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp deleted file mode 100644 index a18d1c866..000000000 --- a/modules/ref/num_of_orderly_violations/func_tests/ref_tests.cpp +++ /dev/null @@ -1,147 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/num_of_orderly_violations/include/ref_task.hpp" - -TEST(num_of_orderly_violations, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - for (size_t i = 0; i < in.size(); i++) { - if (i % 2 == 0) { - in[i] *= -1; - } - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], (in.size() / 2) - 1); -} - -TEST(num_of_orderly_violations, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(num_of_orderly_violations, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - in[1] = -1; - in[200] = -1; - in[456] = -1; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 3ULL); -} - -TEST(num_of_orderly_violations, check_int8_t) { - // Create data - std::vector in(255, -1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 0ULL); -} - -TEST(num_of_orderly_violations, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - for (size_t i = 500; i < in.size() - 600; i++) { - in[i] *= -1; - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 1ULL); -} - -TEST(num_of_orderly_violations, check_float) { - // Create data - std::vector in(3, 1.F); - std::vector out(1, 0); - in[1] = -1.0001F; - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], 1ULL); -} diff --git a/modules/ref/num_of_orderly_violations/include/ref_task.hpp b/modules/ref/num_of_orderly_violations/include/ref_task.hpp deleted file mode 100644 index 261f260c4..000000000 --- a/modules/ref/num_of_orderly_violations/include/ref_task.hpp +++ /dev/null @@ -1,58 +0,0 @@ -#ifndef MODULES_REFERENCE_NUM_OF_ORDERLY_VIOLATIONS_REF_TASK_HPP_ -#define MODULES_REFERENCE_NUM_OF_ORDERLY_VIOLATIONS_REF_TASK_HPP_ - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class NumOfOrderlyViolations : public ppc::core::Task { - public: - explicit NumOfOrderlyViolations(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - num_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 1; - } - - bool RunImpl() override { - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); - - auto temp_res = std::vector(input_.size()); - std::transform(input_.begin(), input_.end(), rotate_in.begin(), temp_res.begin(), - [](InOutType x, InOutType y) { return x > y; }); - - num_ = std::count_if(temp_res.begin(), temp_res.end() - 1, [](InOutType elem) { return elem; }); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = num_; - return true; - } - - private: - std::vector input_; - CountType num_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_NUM_OF_ORDERLY_VIOLATIONS_REF_TASK_HPP_ diff --git a/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp b/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp deleted file mode 100644 index 6375cda41..000000000 --- a/modules/ref/sum_of_vector_elements/func_tests/ref_tests.cpp +++ /dev/null @@ -1,124 +0,0 @@ -#include - -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/sum_of_vector_elements/include/ref_task.hpp" - -TEST(sum_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); -} - -TEST(sum_of_vector_elements, check_validate_func) { - // Create data - std::vector in(125, 1); - std::vector out(2, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(sum_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], in.size(), 1e-6); -} - -TEST(sum_of_vector_elements, check_uint8_t) { - // Create data - std::vector in(255, 1); - std::vector out(1, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); -} - -TEST(sum_of_vector_elements, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in.size()); -} - -TEST(sum_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1.F); - std::vector out(1, 0.F); - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], static_cast(in.size()), 1e-3F); -} diff --git a/modules/ref/sum_of_vector_elements/include/ref_task.hpp b/modules/ref/sum_of_vector_elements/include/ref_task.hpp deleted file mode 100644 index 6fa890657..000000000 --- a/modules/ref/sum_of_vector_elements/include/ref_task.hpp +++ /dev/null @@ -1,47 +0,0 @@ -#pragma once - -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class SumOfVectorElements : public ppc::core::Task { - public: - explicit SumOfVectorElements(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - sum_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 1; - } - - bool RunImpl() override { - sum_ = std::accumulate(input_.begin(), input_.end(), 0); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = sum_; - return true; - } - - private: - std::vector input_; - InOutType sum_; -}; - -} // namespace ppc::reference diff --git a/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp b/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp deleted file mode 100644 index df01adda4..000000000 --- a/modules/ref/sum_values_by_rows_matrix/func_tests/ref_tests.cpp +++ /dev/null @@ -1,196 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/sum_values_by_rows_matrix/include/ref_task.hpp" - -TEST(sum_values_by_rows_matrix, check_int32_t) { - // Create data - std::vector in(1369, 2); - std::vector in_index(2, 37); - std::vector out(37, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - for (size_t i = 0; i < in_index[0]; i++) { - ASSERT_EQ(static_cast(out[0]), 2 * in_index[0]); - } -} - -TEST(sum_values_by_rows_matrix, check_validate_func1) { - // Create data - std::vector in(1369, 2); - std::vector in_index(2, 37); - std::vector out(39, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(sum_values_by_rows_matrix, check_validate_func2) { - // Create data - std::vector in(1369, 2); - std::vector in_index(3, 37); - std::vector out(37, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - auto is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(sum_values_by_rows_matrix, check_double) { - // Create data - std::vector in(1406, 1.0 / 38.0); - std::vector in_index = {37, 38}; - std::vector out(37, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - for (size_t i = 0; i < in_index[0]; i++) { - EXPECT_NEAR(out[i], 1.0, 1e-6); - } -} - -TEST(sum_values_by_rows_matrix, check_int8_t) { - // Create data - std::vector in(1406); - std::vector in_index = {37, 38}; - std::vector out(37, 0); - for (size_t i = 0; i < in.size(); ++i) { - in[i] = (i % 2) != 0 ? -2 : 2; - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - for (size_t i = 0; i < in_index[0]; i++) { - ASSERT_EQ(out[0], 0); - } -} - -TEST(sum_values_by_rows_matrix, check_int64_t) { - // Create data - std::vector in(1406); - std::vector in_index = {37, 38}; - std::vector out(37, 0); - for (size_t i = 0; i < in.size(); ++i) { - in[i] = static_cast((i % 38) + 1); - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - for (size_t i = 0; i < in_index[0]; i++) { - ASSERT_EQ(out[0], static_cast(in_index[1] * (in_index[1] + 1)) / 2); - } -} - -TEST(sum_values_by_rows_matrix, check_float) { - // Create data - std::vector in(1406); - std::vector in_index = {37, 38}; - std::vector out(37, 0.F); - for (size_t i = 0; i < in.size(); ++i) { - in[i] = static_cast((i % 38) + 1); - in[i] *= in[i]; - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in.data())); - task_data->inputs_count.emplace_back(in.size()); - task_data->inputs.emplace_back(reinterpret_cast(in_index.data())); - task_data->inputs_count.emplace_back(in_index.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - for (size_t i = 0; i < in_index[0]; i++) { - EXPECT_NEAR(out[i], in_index[1] * (in_index[1] + 1) * (2 * in_index[1] + 1) / 6.F, 1e-6); - } -} diff --git a/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp b/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp deleted file mode 100644 index ab7412037..000000000 --- a/modules/ref/sum_values_by_rows_matrix/include/ref_task.hpp +++ /dev/null @@ -1,60 +0,0 @@ -#ifndef MODULES_REFERENCE_SUM_VALUES_BY_ROWS_MATRIX_REF_TASK_HPP_ -#define MODULES_REFERENCE_SUM_VALUES_BY_ROWS_MATRIX_REF_TASK_HPP_ - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class SumValuesByRowsMatrix : public ppc::core::Task { - public: - explicit SumValuesByRowsMatrix(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector(task_data->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[0]); - for (unsigned i = 0; i < task_data->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - rows_ = reinterpret_cast(task_data->inputs[1])[0]; - cols_ = reinterpret_cast(task_data->inputs[1])[1]; - - // Init value for output - sum_ = std::vector(cols_, 0.F); - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return static_cast(task_data->inputs_count[1] == 2 && - task_data->outputs_count[0] == reinterpret_cast(task_data->inputs[1])[0]); - } - - bool RunImpl() override { - for (size_t i = 0; i < rows_; i++) { - sum_[i] = std::accumulate(input_.begin() + (cols_ * i), input_.begin() + (cols_ * (i + 1)), 0.F); - } - return true; - } - - bool PostProcessingImpl() override { - for (IndexType i = 0; i < rows_; i++) { - reinterpret_cast(task_data->outputs[0])[i] = sum_[i]; - } - return true; - } - - private: - std::vector input_; - IndexType rows_, cols_; - std::vector sum_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_SUM_VALUES_BY_ROWS_MATRIX_REF_TASK_HPP_ diff --git a/modules/ref/vector_dot_product/func_tests/ref_tests.cpp b/modules/ref/vector_dot_product/func_tests/ref_tests.cpp deleted file mode 100644 index 64d10d7a0..000000000 --- a/modules/ref/vector_dot_product/func_tests/ref_tests.cpp +++ /dev/null @@ -1,189 +0,0 @@ -#include - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" -#include "ref/vector_dot_product/include/ref_task.hpp" - -TEST(vector_dot_product, check_int32_t) { - // Create data - const uint64_t count_data = 1256; - std::vector in1(count_data, 1); - std::vector in2(count_data, 1); - std::vector out(1, 0); - for (size_t i = 0; i < count_data; i++) { - in1[i] = static_cast(i + 1); - in2[i] = static_cast(i + 1); - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), (count_data * (count_data + 1) * (2 * count_data + 1)) / 6); -} - -TEST(vector_dot_product, check_validate_func) { - // Create data - std::vector in1(125, 1); - std::vector in2(125, 1); - std::vector out(2, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(vector_dot_product, check_validate_func_2) { - // Create data - std::vector in1(125, 1); - std::vector in2(124, 1); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, false); -} - -TEST(vector_dot_product, check_double) { - // Create data - std::vector in1(25680, 1.1); - std::vector in2(25680, 1.3); - std::vector out(1, 0); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], in1.size() * 1.1 * 1.3, 1e-6); -} - -TEST(vector_dot_product, check_int8_t) { - // Create data - std::vector in1(126, 1); - std::vector in2(126, 1); - std::vector out(1, 0); - for (size_t i = 0; i < in1.size(); ++i) { - in1[i] = in2[i] = (i % 2 == 0) ? 1 : -1; - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(static_cast(out[0]), in1.size()); -} - -TEST(vector_dot_product, check_int64_t) { - // Create data - const uint64_t count_data = 297; - std::vector in1(count_data, 1); - std::vector in2(count_data, 1); - std::vector out(1, 0); - for (uint64_t i = 0; i < count_data; i++) { - in1[i] = static_cast(i + 1); - in2[i] = static_cast((i + 1) * (i + 1)); - } - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - ASSERT_EQ(out[0], static_cast(count_data * count_data * (count_data + 1) * (count_data + 1)) / 4); -} - -TEST(vector_dot_product, check_float) { - // Create data - std::vector in1(1, -1.3F); - std::vector in2(1, 1.2F); - std::vector out(1, 0.F); - - // Create task_data - auto task_data = std::make_shared(); - task_data->inputs.emplace_back(reinterpret_cast(in1.data())); - task_data->inputs_count.emplace_back(in1.size()); - task_data->inputs.emplace_back(reinterpret_cast(in2.data())); - task_data->inputs_count.emplace_back(in2.size()); - task_data->outputs.emplace_back(reinterpret_cast(out.data())); - task_data->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - test_task.PreProcessing(); - test_task.Run(); - test_task.PostProcessing(); - EXPECT_NEAR(out[0], in1.size() * (-1.3F) * 1.2F, 1e-3F); -} diff --git a/modules/ref/vector_dot_product/include/ref_task.hpp b/modules/ref/vector_dot_product/include/ref_task.hpp deleted file mode 100644 index e4a4559fd..000000000 --- a/modules/ref/vector_dot_product/include/ref_task.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#ifndef MODULES_REFERENCE_VECTOR_DOT_PRODUCT_REF_TASK_HPP_ -#define MODULES_REFERENCE_VECTOR_DOT_PRODUCT_REF_TASK_HPP_ - -#include -#include -#include -#include - -#include "core/task/include/task.hpp" - -namespace ppc::reference { - -template -class VectorDotProduct : public ppc::core::Task { - public: - explicit VectorDotProduct(ppc::core::TaskDataPtr task_data) : Task(task_data) {} - bool PreProcessingImpl() override { - // Init vectors - input_ = std::vector>(2); - for (size_t i = 0; i < input_.size(); i++) { - input_[i] = std::vector(task_data->inputs_count[i]); - auto tmp_ptr = reinterpret_cast(task_data->inputs[i]); - for (unsigned j = 0; j < task_data->inputs_count[i]; j++) { - input_[i][j] = tmp_ptr[j]; - } - } - - // Init value for output - dor_product_ = 0; - return true; - } - - bool ValidationImpl() override { - // Check count elements of output - return task_data->outputs_count[0] == 1 && task_data->inputs_count[0] == task_data->inputs_count[1]; - } - - bool RunImpl() override { - dor_product_ = std::inner_product(input_[0].begin(), input_[0].end(), input_[1].begin(), 0.0); - return true; - } - - bool PostProcessingImpl() override { - reinterpret_cast(task_data->outputs[0])[0] = dor_product_; - return true; - } - - private: - std::vector> input_; - InOutType dor_product_; -}; - -} // namespace ppc::reference - -#endif // MODULES_REFERENCE_VECTOR_DOT_PRODUCT_REF_TASK_HPP_ diff --git a/tasks/stl/example/func_tests/main.cpp b/tasks/stl/example/func_tests/main.cpp index 77ffa5a5c..5825054df 100644 --- a/tasks/stl/example/func_tests/main.cpp +++ b/tasks/stl/example/func_tests/main.cpp @@ -16,26 +16,18 @@ TEST(nesterov_a_test_task_stl, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_stl = std::make_shared(); - task_data_stl->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_stl->inputs_count.emplace_back(in.size()); - task_data_stl->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_stl->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_stl::TestTaskSTL test_task_stl(task_data_stl); + nesterov_a_test_task_stl::TestTaskSTL test_task_stl(in); ASSERT_EQ(test_task_stl.Validation(), true); test_task_stl.PreProcessing(); test_task_stl.Run(); test_task_stl.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_stl.Get()); } TEST(nesterov_a_test_task_stl, test_matmul_100_from_file) { @@ -50,24 +42,16 @@ TEST(nesterov_a_test_task_stl, test_matmul_100_from_file) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_stl = std::make_shared(); - task_data_stl->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_stl->inputs_count.emplace_back(in.size()); - task_data_stl->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_stl->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_stl::TestTaskSTL test_task_stl(task_data_stl); + nesterov_a_test_task_stl::TestTaskSTL test_task_stl(in); ASSERT_EQ(test_task_stl.Validation(), true); test_task_stl.PreProcessing(); test_task_stl.Run(); test_task_stl.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_stl.Get()); } diff --git a/tasks/stl/example/include/ops_stl.hpp b/tasks/stl/example/include/ops_stl.hpp index 05b6b6dbf..647993d22 100644 --- a/tasks/stl/example/include/ops_stl.hpp +++ b/tasks/stl/example/include/ops_stl.hpp @@ -9,11 +9,14 @@ namespace nesterov_a_test_task_stl { class TestTaskSTL : public ppc::core::Task { public: - explicit TestTaskSTL(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} - bool PreProcessingImpl() override; + explicit TestTaskSTL(const std::vector& in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/stl/example/perf_tests/main.cpp b/tasks/stl/example/perf_tests/main.cpp index e7937bcec..0ce84dd58 100644 --- a/tasks/stl/example/perf_tests/main.cpp +++ b/tasks/stl/example/perf_tests/main.cpp @@ -15,25 +15,16 @@ TEST(nesterov_a_test_task_stl, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_seq->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_sequential = std::make_shared(task_data_seq); + auto test_task_sequential = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -48,7 +39,7 @@ TEST(nesterov_a_test_task_stl, test_pipeline_run) { auto perf_analyzer = std::make_shared(test_task_sequential); perf_analyzer->PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_sequential->Get()); } TEST(nesterov_a_test_task_stl, test_task_run) { @@ -56,25 +47,16 @@ TEST(nesterov_a_test_task_stl, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_seq = std::make_shared(); - task_data_seq->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_seq->inputs_count.emplace_back(in.size()); - task_data_seq->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_seq->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_sequential = std::make_shared(task_data_seq); + auto test_task_sequential = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -89,5 +71,5 @@ TEST(nesterov_a_test_task_stl, test_task_run) { auto perf_analyzer = std::make_shared(test_task_sequential); perf_analyzer->TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_sequential->Get()); } diff --git a/tasks/stl/example/src/ops_stl.cpp b/tasks/stl/example/src/ops_stl.cpp index 199935889..d42cc02fe 100644 --- a/tasks/stl/example/src/ops_stl.cpp +++ b/tasks/stl/example/src/ops_stl.cpp @@ -21,22 +21,15 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v } } // namespace -bool nesterov_a_test_task_stl::TestTaskSTL::PreProcessingImpl() { - // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); - return true; +bool nesterov_a_test_task_stl::TestTaskSTL::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); } -bool nesterov_a_test_task_stl::TestTaskSTL::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; +bool nesterov_a_test_task_stl::TestTaskSTL::PreProcessingImpl() { + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(input_.size(), 0); + return true; } bool nesterov_a_test_task_stl::TestTaskSTL::RunImpl() { @@ -50,8 +43,5 @@ bool nesterov_a_test_task_stl::TestTaskSTL::RunImpl() { } bool nesterov_a_test_task_stl::TestTaskSTL::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From eea042eaf6a2465c9d5a55b0569942a1fcb3ca07 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:44:08 +0200 Subject: [PATCH 07/22] change tbb dir --- tasks/tbb/example/func_tests/main.cpp | 24 ++++-------------------- tasks/tbb/example/include/ops_tbb.hpp | 7 +++++-- tasks/tbb/example/perf_tests/main.cpp | 27 ++++----------------------- tasks/tbb/example/src/ops_tbb.cpp | 24 +++++++----------------- 4 files changed, 20 insertions(+), 62 deletions(-) diff --git a/tasks/tbb/example/func_tests/main.cpp b/tasks/tbb/example/func_tests/main.cpp index 3e1ac5a8a..c4b86a30b 100644 --- a/tasks/tbb/example/func_tests/main.cpp +++ b/tasks/tbb/example/func_tests/main.cpp @@ -16,26 +16,18 @@ TEST(nesterov_a_test_task_tbb, test_matmul_50) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_tbb = std::make_shared(); - task_data_tbb->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_tbb->inputs_count.emplace_back(in.size()); - task_data_tbb->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_tbb->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(task_data_tbb); + nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(in); ASSERT_EQ(test_task_tbb.Validation(), true); test_task_tbb.PreProcessing(); test_task_tbb.Run(); test_task_tbb.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_tbb.Get()); } TEST(nesterov_a_test_task_tbb, test_matmul_100_from_file) { @@ -50,24 +42,16 @@ TEST(nesterov_a_test_task_tbb, test_matmul_100_from_file) { // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create task_data - auto task_data_tbb = std::make_shared(); - task_data_tbb->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_tbb->inputs_count.emplace_back(in.size()); - task_data_tbb->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_tbb->outputs_count.emplace_back(out.size()); - // Create Task - nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(task_data_tbb); + nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(in); ASSERT_EQ(test_task_tbb.Validation(), true); test_task_tbb.PreProcessing(); test_task_tbb.Run(); test_task_tbb.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_tbb.Get()); } diff --git a/tasks/tbb/example/include/ops_tbb.hpp b/tasks/tbb/example/include/ops_tbb.hpp index 4e6286bd5..dd8101a3b 100644 --- a/tasks/tbb/example/include/ops_tbb.hpp +++ b/tasks/tbb/example/include/ops_tbb.hpp @@ -9,11 +9,14 @@ namespace nesterov_a_test_task_tbb { class TestTaskTBB : public ppc::core::Task { public: - explicit TestTaskTBB(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} - bool PreProcessingImpl() override; + explicit TestTaskTBB(const std::vector& in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get() { + return output_; + } private: std::vector input_, output_; diff --git a/tasks/tbb/example/perf_tests/main.cpp b/tasks/tbb/example/perf_tests/main.cpp index 7a6fee999..02e197d56 100644 --- a/tasks/tbb/example/perf_tests/main.cpp +++ b/tasks/tbb/example/perf_tests/main.cpp @@ -15,25 +15,16 @@ TEST(nesterov_a_test_task_tbb, test_pipeline_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_tbb = std::make_shared(); - task_data_tbb->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_tbb->inputs_count.emplace_back(in.size()); - task_data_tbb->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_tbb->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_tbb = std::make_shared(task_data_tbb); + auto test_task_tbb = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -48,7 +39,7 @@ TEST(nesterov_a_test_task_tbb, test_pipeline_run) { auto perf_analyzer = std::make_shared(test_task_tbb); perf_analyzer->PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_tbb->Get()); } TEST(nesterov_a_test_task_tbb, test_task_run) { @@ -56,25 +47,15 @@ TEST(nesterov_a_test_task_tbb, test_task_run) { // Create data std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); - for (size_t i = 0; i < kCount; i++) { in[(i * kCount) + i] = 1; } - // Create task_data - auto task_data_tbb = std::make_shared(); - task_data_tbb->inputs.emplace_back(reinterpret_cast(in.data())); - task_data_tbb->inputs_count.emplace_back(in.size()); - task_data_tbb->outputs.emplace_back(reinterpret_cast(out.data())); - task_data_tbb->outputs_count.emplace_back(out.size()); - // Create Task - auto test_task_tbb = std::make_shared(task_data_tbb); + auto test_task_tbb = std::make_shared(in); // Create Perf attributes auto perf_attr = std::make_shared(); - 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(); @@ -89,5 +70,5 @@ TEST(nesterov_a_test_task_tbb, test_task_run) { auto perf_analyzer = std::make_shared(test_task_tbb); perf_analyzer->TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, out); + ASSERT_EQ(in, test_task_tbb->Get()); } diff --git a/tasks/tbb/example/src/ops_tbb.cpp b/tasks/tbb/example/src/ops_tbb.cpp index 730dfaf5b..1a62d3520 100644 --- a/tasks/tbb/example/src/ops_tbb.cpp +++ b/tasks/tbb/example/src/ops_tbb.cpp @@ -23,22 +23,15 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v } } // namespace -bool nesterov_a_test_task_tbb::TestTaskTBB::PreProcessingImpl() { - // Init value for input and output - unsigned int input_size = task_data->inputs_count[0]; - auto *in_ptr = reinterpret_cast(task_data->inputs[0]); - input_ = std::vector(in_ptr, in_ptr + input_size); - - unsigned int output_size = task_data->outputs_count[0]; - output_ = std::vector(output_size, 0); - - rc_size_ = static_cast(std::sqrt(input_size)); - return true; +bool nesterov_a_test_task_tbb::TestTaskTBB::ValidationImpl() { + auto sqrt_size = static_cast(std::sqrt(input_.size())); + return sqrt_size * sqrt_size == static_cast(input_.size()); } -bool nesterov_a_test_task_tbb::TestTaskTBB::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; +bool nesterov_a_test_task_tbb::TestTaskTBB::PreProcessingImpl() { + rc_size_ = static_cast(std::sqrt(input_.size())); + output_ = std::vector(input_.size(), 0); + return true; } bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { @@ -54,8 +47,5 @@ bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { } bool nesterov_a_test_task_tbb::TestTaskTBB::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } return true; } From 65294a46014c0029579d026611235246bd13a742 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:46:50 +0200 Subject: [PATCH 08/22] fix clang format --- modules/core/perf/func_tests/test_task.hpp | 8 ++------ modules/core/task/func_tests/test_task.hpp | 8 ++------ modules/core/task/include/task.hpp | 4 +--- tasks/all/example/include/ops_all.hpp | 4 +--- tasks/all/example/src/ops_all.cpp | 4 +--- tasks/mpi/example/include/ops_mpi.hpp | 4 +--- tasks/mpi/example/src/ops_mpi.cpp | 4 +--- tasks/omp/example/include/ops_omp.hpp | 4 +--- tasks/omp/example/src/ops_omp.cpp | 4 +--- tasks/seq/example/include/ops_seq.hpp | 4 +--- tasks/seq/example/src/ops_seq.cpp | 4 +--- tasks/stl/example/include/ops_stl.hpp | 4 +--- tasks/stl/example/src/ops_stl.cpp | 4 +--- tasks/tbb/example/include/ops_tbb.hpp | 4 +--- tasks/tbb/example/src/ops_tbb.cpp | 4 +--- 15 files changed, 17 insertions(+), 51 deletions(-) diff --git a/modules/core/perf/func_tests/test_task.hpp b/modules/core/perf/func_tests/test_task.hpp index e83806194..3a9982765 100644 --- a/modules/core/perf/func_tests/test_task.hpp +++ b/modules/core/perf/func_tests/test_task.hpp @@ -14,9 +14,7 @@ class TestTask : public ppc::core::Task { public: explicit TestTask(const std::vector& in) : input_(in) {} - bool ValidationImpl() override { - return !input_.empty(); - } + bool ValidationImpl() override { return !input_.empty(); } bool PreProcessingImpl() override { output_ = 0; @@ -30,9 +28,7 @@ class TestTask : public ppc::core::Task { return true; } - bool PostProcessingImpl() override { - return true; - } + bool PostProcessingImpl() override { return true; } T Get() { return output_; } diff --git a/modules/core/task/func_tests/test_task.hpp b/modules/core/task/func_tests/test_task.hpp index 0ef4f59b2..ec79cefbf 100644 --- a/modules/core/task/func_tests/test_task.hpp +++ b/modules/core/task/func_tests/test_task.hpp @@ -13,9 +13,7 @@ class TestTask : public ppc::core::Task { public: explicit TestTask(const std::vector& in) : input_(in) {} - bool ValidationImpl() override { - return !input_.empty(); - } + bool ValidationImpl() override { return !input_.empty(); } bool PreProcessingImpl() override { output_ = 0; @@ -29,9 +27,7 @@ class TestTask : public ppc::core::Task { return true; } - bool PostProcessingImpl() override { - return true; - } + bool PostProcessingImpl() override { return true; } T Get() { return output_; } diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp index 185792d32..9910a1ac3 100644 --- a/modules/core/task/include/task.hpp +++ b/modules/core/task/include/task.hpp @@ -29,9 +29,7 @@ class Task { virtual bool PostProcessing() final; // get state of testing - StateOfTesting& GetStateOfTesting() { - return state_of_testing_; - } + StateOfTesting &GetStateOfTesting() { return state_of_testing_; } virtual ~Task(); diff --git a/tasks/all/example/include/ops_all.hpp b/tasks/all/example/include/ops_all.hpp index 864642ade..49f589a57 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -14,9 +14,7 @@ class TestTaskALL : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index c40728344..cdcb3a8fa 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -68,6 +68,4 @@ bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { return true; } -bool nesterov_a_test_task_all::TestTaskALL::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_all::TestTaskALL::PostProcessingImpl() { return true; } diff --git a/tasks/mpi/example/include/ops_mpi.hpp b/tasks/mpi/example/include/ops_mpi.hpp index 6804eeb50..b7e88e54a 100644 --- a/tasks/mpi/example/include/ops_mpi.hpp +++ b/tasks/mpi/example/include/ops_mpi.hpp @@ -14,9 +14,7 @@ class TestTaskMPI : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/mpi/example/src/ops_mpi.cpp b/tasks/mpi/example/src/ops_mpi.cpp index 842669bec..c74286652 100644 --- a/tasks/mpi/example/src/ops_mpi.cpp +++ b/tasks/mpi/example/src/ops_mpi.cpp @@ -55,6 +55,4 @@ void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyColumnMajor() { } } -bool nesterov_a_test_task_mpi::TestTaskMPI::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_mpi::TestTaskMPI::PostProcessingImpl() { return true; } diff --git a/tasks/omp/example/include/ops_omp.hpp b/tasks/omp/example/include/ops_omp.hpp index 4a90d4f59..607297f29 100644 --- a/tasks/omp/example/include/ops_omp.hpp +++ b/tasks/omp/example/include/ops_omp.hpp @@ -14,9 +14,7 @@ class TestTaskOpenMP : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/omp/example/src/ops_omp.cpp b/tasks/omp/example/src/ops_omp.cpp index d0a913bbc..910efc28a 100644 --- a/tasks/omp/example/src/ops_omp.cpp +++ b/tasks/omp/example/src/ops_omp.cpp @@ -34,6 +34,4 @@ bool nesterov_a_test_task_omp::TestTaskOpenMP::RunImpl() { return true; } -bool nesterov_a_test_task_omp::TestTaskOpenMP::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_omp::TestTaskOpenMP::PostProcessingImpl() { return true; } diff --git a/tasks/seq/example/include/ops_seq.hpp b/tasks/seq/example/include/ops_seq.hpp index d720c96ea..be9e0f18c 100644 --- a/tasks/seq/example/include/ops_seq.hpp +++ b/tasks/seq/example/include/ops_seq.hpp @@ -14,9 +14,7 @@ class TestTaskSequential : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/seq/example/src/ops_seq.cpp b/tasks/seq/example/src/ops_seq.cpp index 2ee537e55..86e9893c0 100644 --- a/tasks/seq/example/src/ops_seq.cpp +++ b/tasks/seq/example/src/ops_seq.cpp @@ -27,6 +27,4 @@ bool nesterov_a_test_task_seq::TestTaskSequential::RunImpl() { return true; } -bool nesterov_a_test_task_seq::TestTaskSequential::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_seq::TestTaskSequential::PostProcessingImpl() { return true; } diff --git a/tasks/stl/example/include/ops_stl.hpp b/tasks/stl/example/include/ops_stl.hpp index 647993d22..dcd9b386c 100644 --- a/tasks/stl/example/include/ops_stl.hpp +++ b/tasks/stl/example/include/ops_stl.hpp @@ -14,9 +14,7 @@ class TestTaskSTL : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/stl/example/src/ops_stl.cpp b/tasks/stl/example/src/ops_stl.cpp index d42cc02fe..a6682e502 100644 --- a/tasks/stl/example/src/ops_stl.cpp +++ b/tasks/stl/example/src/ops_stl.cpp @@ -42,6 +42,4 @@ bool nesterov_a_test_task_stl::TestTaskSTL::RunImpl() { return true; } -bool nesterov_a_test_task_stl::TestTaskSTL::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_stl::TestTaskSTL::PostProcessingImpl() { return true; } diff --git a/tasks/tbb/example/include/ops_tbb.hpp b/tasks/tbb/example/include/ops_tbb.hpp index dd8101a3b..33935d181 100644 --- a/tasks/tbb/example/include/ops_tbb.hpp +++ b/tasks/tbb/example/include/ops_tbb.hpp @@ -14,9 +14,7 @@ class TestTaskTBB : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { - return output_; - } + std::vector Get() { return output_; } private: std::vector input_, output_; diff --git a/tasks/tbb/example/src/ops_tbb.cpp b/tasks/tbb/example/src/ops_tbb.cpp index 1a62d3520..b4e735ced 100644 --- a/tasks/tbb/example/src/ops_tbb.cpp +++ b/tasks/tbb/example/src/ops_tbb.cpp @@ -46,6 +46,4 @@ bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { return true; } -bool nesterov_a_test_task_tbb::TestTaskTBB::PostProcessingImpl() { - return true; -} +bool nesterov_a_test_task_tbb::TestTaskTBB::PostProcessingImpl() { return true; } From d8a14749101574cea6920a4c39446dd8bb9f6a2e Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 18:53:31 +0200 Subject: [PATCH 09/22] remove ref from scripts --- scripts/run_tests.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/scripts/run_tests.py b/scripts/run_tests.py index 6c949e0e1..68e01cb47 100644 --- a/scripts/run_tests.py +++ b/scripts/run_tests.py @@ -94,10 +94,8 @@ def run_threads(self): def run_core(self): if platform.system() == "Linux" and not os.environ.get("ASAN_RUN"): self.__run_exec(f"{self.valgrind_cmd} {self.work_dir / 'core_func_tests'} {self.__get_gtest_settings(1)}") - self.__run_exec(f"{self.valgrind_cmd} {self.work_dir / 'ref_func_tests'} {self.__get_gtest_settings(1)}") self.__run_exec(f"{self.work_dir / 'core_func_tests'} {self.__get_gtest_settings(1)}") - self.__run_exec(f"{self.work_dir / 'ref_func_tests'} {self.__get_gtest_settings(1)}") def run_processes(self, additional_mpi_args): if os.environ.get("CLANG_BUILD") == "1": From 7d9558a12dca0286209243fc8fef0b4852e2b580 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 19:30:51 +0200 Subject: [PATCH 10/22] change perf api --- modules/core/perf/func_tests/perf_tests.cpp | 36 ++++++++++----------- modules/core/perf/include/perf.hpp | 11 +++---- modules/core/perf/src/perf.cpp | 30 ++++++++--------- tasks/all/example/perf_tests/perf_all.cpp | 22 +++++++------ tasks/mpi/example/perf_tests/main.cpp | 20 ++++++------ tasks/omp/example/perf_tests/main.cpp | 22 +++++++------ tasks/seq/example/perf_tests/main.cpp | 22 +++++++------ tasks/stl/example/perf_tests/main.cpp | 21 ++++++------ tasks/tbb/example/perf_tests/main.cpp | 16 ++++----- 9 files changed, 102 insertions(+), 98 deletions(-) diff --git a/modules/core/perf/func_tests/perf_tests.cpp b/modules/core/perf/func_tests/perf_tests.cpp index 5870ca874..bd24ba687 100644 --- a/modules/core/perf/func_tests/perf_tests.cpp +++ b/modules/core/perf/func_tests/perf_tests.cpp @@ -17,10 +17,10 @@ TEST(perf_tests, check_perf_pipeline) { auto test_task = std::make_shared>(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); @@ -28,7 +28,7 @@ TEST(perf_tests, check_perf_pipeline) { // Get perf statistic ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); + ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } @@ -40,10 +40,10 @@ TEST(perf_tests, check_perf_pipeline_float) { auto test_task = std::make_shared>(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); @@ -51,7 +51,7 @@ TEST(perf_tests, check_perf_pipeline_float) { // Get perf statistic ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); + ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } @@ -63,18 +63,18 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { auto test_task = std::make_shared>(in); // Create Perf attributes - auto perf_attr = std::make_shared(); - perf_attr->num_running = 1; + ppc::core::PerfAttr perf_attr; + perf_attr.num_running = 1; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); @@ -92,19 +92,19 @@ TEST(perf_tests, check_perf_task) { auto test_task = std::make_shared>(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); perf_analyzer.TaskRun(perf_attr, perf_results); // Get perf statistic - perf_results->type_of_running = ppc::core::PerfResults::kNone; + perf_results.type_of_running = ppc::core::PerfResults::kNone; ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); + ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } @@ -116,18 +116,18 @@ TEST(perf_tests, check_perf_task_float) { auto test_task = std::make_shared>(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); perf_analyzer.TaskRun(perf_attr, perf_results); // Get perf statistic - perf_results->type_of_running = ppc::core::PerfResults::kPipeline; + perf_results.type_of_running = ppc::core::PerfResults::kPipeline; ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); + ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } diff --git a/modules/core/perf/include/perf.hpp b/modules/core/perf/include/perf.hpp index 42ce31ef7..2fe5c2fea 100644 --- a/modules/core/perf/include/perf.hpp +++ b/modules/core/perf/include/perf.hpp @@ -25,21 +25,20 @@ class Perf { public: // Init performance analysis with initialized task and initialized data explicit Perf(const std::shared_ptr& task_ptr); - // Set task with initialized task and initialized data for performance + // Set task with an initialized task and initialized data for performance // analysis c void SetTask(const std::shared_ptr& task_ptr); // Check performance of full task's pipeline: PreProcessing() -> // Validation() -> Run() -> PostProcessing() - void PipelineRun(const std::shared_ptr& perf_attr, const std::shared_ptr& perf_results) const; + void PipelineRun(const PerfAttr& perf_attr, PerfResults& perf_results) const; // Check performance of task's Run() function - void TaskRun(const std::shared_ptr& perf_attr, const std::shared_ptr& perf_results) const; + void TaskRun(const PerfAttr& perf_attr, PerfResults& perf_results) const; // Pint results for automation checkers - static void PrintPerfStatistic(const std::shared_ptr& perf_results); + static void PrintPerfStatistic(const PerfResults& perf_results); private: std::shared_ptr task_; - static void CommonRun(const std::shared_ptr& perf_attr, const std::function& pipeline, - const std::shared_ptr& perf_results); + static void CommonRun(const PerfAttr& perf_attr, const std::function& pipeline, PerfResults& perf_results); }; } // namespace ppc::core diff --git a/modules/core/perf/src/perf.cpp b/modules/core/perf/src/perf.cpp index db325c88b..f66cbbd49 100644 --- a/modules/core/perf/src/perf.cpp +++ b/modules/core/perf/src/perf.cpp @@ -20,9 +20,8 @@ void ppc::core::Perf::SetTask(const std::shared_ptr& task_ptr) { this->task_ = task_ptr; } -void ppc::core::Perf::PipelineRun(const std::shared_ptr& perf_attr, - const std::shared_ptr& perf_results) const { - perf_results->type_of_running = PerfResults::TypeOfRunning::kPipeline; +void ppc::core::Perf::PipelineRun(const PerfAttr& perf_attr, ppc::core::PerfResults& perf_results) const { + perf_results.type_of_running = PerfResults::TypeOfRunning::kPipeline; CommonRun( perf_attr, @@ -35,9 +34,8 @@ void ppc::core::Perf::PipelineRun(const std::shared_ptr& perf_attr, perf_results); } -void ppc::core::Perf::TaskRun(const std::shared_ptr& perf_attr, - const std::shared_ptr& perf_results) const { - perf_results->type_of_running = PerfResults::TypeOfRunning::kTaskRun; +void ppc::core::Perf::TaskRun(const PerfAttr& perf_attr, ppc::core::PerfResults& perf_results) const { + perf_results.type_of_running = PerfResults::TypeOfRunning::kTaskRun; task_->Validation(); task_->PreProcessing(); @@ -50,27 +48,27 @@ void ppc::core::Perf::TaskRun(const std::shared_ptr& perf_attr, task_->PostProcessing(); } -void ppc::core::Perf::CommonRun(const std::shared_ptr& perf_attr, const std::function& pipeline, - const std::shared_ptr& perf_results) { - auto begin = perf_attr->current_timer(); - for (uint64_t i = 0; i < perf_attr->num_running; i++) { +void ppc::core::Perf::CommonRun(const PerfAttr& perf_attr, const std::function& pipeline, + ppc::core::PerfResults& perf_results) { + auto begin = perf_attr.current_timer(); + for (uint64_t i = 0; i < perf_attr.num_running; i++) { pipeline(); } - auto end = perf_attr->current_timer(); - perf_results->time_sec = end - begin; + auto end = perf_attr.current_timer(); + perf_results.time_sec = end - begin; } -void ppc::core::Perf::PrintPerfStatistic(const std::shared_ptr& perf_results) { +void ppc::core::Perf::PrintPerfStatistic(const PerfResults& perf_results) { std::string relative_path(::testing::UnitTest::GetInstance()->current_test_info()->file()); std::string ppc_regex_template("parallel_programming_course"); std::string perf_regex_template("perf_tests"); std::string type_test_name; - auto time_secs = perf_results->time_sec; + auto time_secs = perf_results.time_sec; - if (perf_results->type_of_running == PerfResults::TypeOfRunning::kTaskRun) { + if (perf_results.type_of_running == PerfResults::TypeOfRunning::kTaskRun) { type_test_name = "task_run"; - } else if (perf_results->type_of_running == PerfResults::TypeOfRunning::kPipeline) { + } else if (perf_results.type_of_running == PerfResults::TypeOfRunning::kPipeline) { type_test_name = "pipeline"; } else { type_test_name = "none"; diff --git a/tasks/all/example/perf_tests/perf_all.cpp b/tasks/all/example/perf_tests/perf_all.cpp index 2bee7c285..6626a6774 100644 --- a/tasks/all/example/perf_tests/perf_all.cpp +++ b/tasks/all/example/perf_tests/perf_all.cpp @@ -25,19 +25,20 @@ TEST(nesterov_a_test_task_all, test_pipeline_run) { auto test_task_all = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; - auto perf_analyzer = std::make_shared(test_task_all); - perf_analyzer->PipelineRun(perf_attr, perf_results); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_all); + perf_analyzer.PipelineRun(perf_attr, perf_results); // Create Perf analyzer int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); @@ -62,20 +63,21 @@ TEST(nesterov_a_test_task_all, test_task_run) { auto test_task_all = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_all); - perf_analyzer->TaskRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_all); + perf_analyzer.TaskRun(perf_attr, perf_results); + // Create Perf analyzer int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index de866ff81..a5979e9b5 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -25,19 +25,19 @@ TEST(nesterov_a_test_task_mpi, test_pipeline_run) { auto test_task_mpi = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; - auto perf_analyzer = std::make_shared(test_task_mpi); - perf_analyzer->PipelineRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_mpi); + perf_analyzer.PipelineRun(perf_attr, perf_results); // Create Perf analyzer int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); @@ -62,20 +62,20 @@ TEST(nesterov_a_test_task_mpi, test_task_run) { auto test_task_mpi = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_mpi); - perf_analyzer->TaskRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_mpi); + perf_analyzer.TaskRun(perf_attr, perf_results); // Create Perf analyzer int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); diff --git a/tasks/omp/example/perf_tests/main.cpp b/tasks/omp/example/perf_tests/main.cpp index d63786d8a..b30fdf1c7 100644 --- a/tasks/omp/example/perf_tests/main.cpp +++ b/tasks/omp/example/perf_tests/main.cpp @@ -24,21 +24,22 @@ TEST(nesterov_a_test_task_omp, test_pipeline_run) { auto test_task_omp = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_omp); - perf_analyzer->PipelineRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_omp); + perf_analyzer.PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); + ASSERT_EQ(in, test_task_omp->Get()); } @@ -56,20 +57,21 @@ TEST(nesterov_a_test_task_omp, test_task_run) { auto test_task_omp = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_omp); - perf_analyzer->TaskRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_omp); + perf_analyzer.TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); + ASSERT_EQ(in, test_task_omp->Get()); } diff --git a/tasks/seq/example/perf_tests/main.cpp b/tasks/seq/example/perf_tests/main.cpp index e04d44572..13a5b2782 100644 --- a/tasks/seq/example/perf_tests/main.cpp +++ b/tasks/seq/example/perf_tests/main.cpp @@ -24,21 +24,22 @@ TEST(nesterov_a_test_task_seq, test_pipeline_run) { auto test_task_sequential = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_sequential); - perf_analyzer->PipelineRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_sequential); + perf_analyzer.PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); + ASSERT_EQ(in, test_task_sequential->Get()); } @@ -56,20 +57,21 @@ TEST(nesterov_a_test_task_seq, test_task_run) { auto test_task_sequential = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_sequential); - perf_analyzer->TaskRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_sequential); + perf_analyzer.TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); + ASSERT_EQ(in, test_task_sequential->Get()); } diff --git a/tasks/stl/example/perf_tests/main.cpp b/tasks/stl/example/perf_tests/main.cpp index 0ce84dd58..a6b84a7fd 100644 --- a/tasks/stl/example/perf_tests/main.cpp +++ b/tasks/stl/example/perf_tests/main.cpp @@ -24,21 +24,22 @@ TEST(nesterov_a_test_task_stl, test_pipeline_run) { auto test_task_sequential = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_sequential); - perf_analyzer->PipelineRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_sequential); + perf_analyzer.PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); + ASSERT_EQ(in, test_task_sequential->Get()); } @@ -56,20 +57,20 @@ TEST(nesterov_a_test_task_stl, test_task_run) { auto test_task_sequential = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_sequential); - perf_analyzer->TaskRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_sequential); + perf_analyzer.TaskRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_EQ(in, test_task_sequential->Get()); } diff --git a/tasks/tbb/example/perf_tests/main.cpp b/tasks/tbb/example/perf_tests/main.cpp index 02e197d56..7779dcea9 100644 --- a/tasks/tbb/example/perf_tests/main.cpp +++ b/tasks/tbb/example/perf_tests/main.cpp @@ -24,20 +24,20 @@ TEST(nesterov_a_test_task_tbb, test_pipeline_run) { auto test_task_tbb = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_tbb); - perf_analyzer->PipelineRun(perf_attr, perf_results); + ppc::core::Perf perf_analyzer(test_task_tbb); + perf_analyzer.PipelineRun(perf_attr, perf_results); ppc::core::Perf::PrintPerfStatistic(perf_results); ASSERT_EQ(in, test_task_tbb->Get()); } @@ -55,16 +55,16 @@ TEST(nesterov_a_test_task_tbb, test_task_run) { auto test_task_tbb = std::make_shared(in); // Create Perf attributes - auto perf_attr = std::make_shared(); + ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); - perf_attr->current_timer = [&] { + perf_attr.current_timer = [&] { auto current_time_point = std::chrono::high_resolution_clock::now(); auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; // Create and init perf results - auto perf_results = std::make_shared(); + ppc::core::PerfResults perf_results; // Create Perf analyzer auto perf_analyzer = std::make_shared(test_task_tbb); From 58c14665c80ff7296915c9e2e50bcc53e595382b Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 20:02:27 +0200 Subject: [PATCH 11/22] refactor func tests in tasks --- tasks/all/example/func_tests/func_all.cpp | 60 ----------------------- tasks/all/example/func_tests/main.cpp | 52 ++++++++++++++++++++ tasks/mpi/example/func_tests/main.cpp | 53 +++++++++----------- tasks/omp/example/func_tests/main.cpp | 53 +++++++++----------- tasks/seq/example/func_tests/main.cpp | 50 +++++++++---------- tasks/stl/example/func_tests/main.cpp | 53 +++++++++----------- tasks/tbb/example/func_tests/main.cpp | 53 +++++++++----------- 7 files changed, 169 insertions(+), 205 deletions(-) delete mode 100644 tasks/all/example/func_tests/func_all.cpp create mode 100644 tasks/all/example/func_tests/main.cpp diff --git a/tasks/all/example/func_tests/func_all.cpp b/tasks/all/example/func_tests/func_all.cpp deleted file mode 100644 index e72581dd0..000000000 --- a/tasks/all/example/func_tests/func_all.cpp +++ /dev/null @@ -1,60 +0,0 @@ -#include - -#include -#include -#include -#include -#include -#include - -#include "all/example/include/ops_all.hpp" -#include "core/task/include/task.hpp" -#include "core/util/include/util.hpp" - -TEST(nesterov_a_test_task_all, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - nesterov_a_test_task_all::TestTaskALL test_task_all(in); - ASSERT_EQ(test_task_all.Validation(), true); - test_task_all.PreProcessing(); - test_task_all.Run(); - test_task_all.PostProcessing(); - EXPECT_EQ(in, test_task_all.Get()); -} - -TEST(nesterov_a_test_task_all, test_matmul_from_pic) { - int width = -1; - int height = -1; - int channels = -1; - std::string abs_path = ppc::util::GetAbsolutePath("all/example/data/pic_all.jpg"); - unsigned char *data = stbi_load(abs_path.c_str(), &width, &height, &channels, 0); - EXPECT_TRUE(data != nullptr) << "Failed to load image: " << stbi_failure_reason() << '\n'; - auto img = std::vector(data, data + (width * height * channels)); - stbi_image_free(data); - - EXPECT_EQ(width, height); - const int count = (width + height) / 10; - - // Create data - std::vector in(count * count, 0); - - for (int i = 0; i < count; i++) { - in[(i * count) + i] = 1; - } - - // Create Task - nesterov_a_test_task_all::TestTaskALL test_task_all(in); - ASSERT_EQ(test_task_all.Validation(), true); - test_task_all.PreProcessing(); - test_task_all.Run(); - test_task_all.PostProcessing(); - EXPECT_EQ(in, test_task_all.Get()); -} diff --git a/tasks/all/example/func_tests/main.cpp b/tasks/all/example/func_tests/main.cpp new file mode 100644 index 000000000..d6b24c238 --- /dev/null +++ b/tasks/all/example/func_tests/main.cpp @@ -0,0 +1,52 @@ +#include + +#include +#include +#include +#include +#include +#include + +#include "all/example/include/ops_all.hpp" +#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" + +class NesterovATestTaskAll : public ::testing::TestWithParam { + protected: + void SetUp() override { + width = height = channels = -1; + std::string abs_path = ppc::util::GetAbsolutePath("all/example/data/pic_all.jpg"); + data = stbi_load(abs_path.c_str(), &width, &height, &channels, 0); + ASSERT_TRUE(data != nullptr) << "Failed to load image: " << stbi_failure_reason(); + img = std::vector(data, data + (width * height * channels)); + stbi_image_free(data); + + ASSERT_EQ(width, height); + } + + int width = -1, height = -1, channels = -1; + unsigned char* data = nullptr; + std::vector img; +}; + +TEST_P(NesterovATestTaskAll, MatmulFromPic) { + int divider = GetParam(); + const int k_count = (width + height) / divider; + + std::vector in(k_count * k_count, 0); + for (int i = 0; i < k_count; i++) { + in[(i * k_count) + i] = 1; + } + + nesterov_a_test_task_all::TestTaskALL test_task_all(in); + ASSERT_TRUE(test_task_all.Validation()); + test_task_all.PreProcessing(); + test_task_all.Run(); + test_task_all.PostProcessing(); + EXPECT_EQ(in, test_task_all.Get()); +} + +INSTANTIATE_TEST_SUITE_P( + PicMatrixTests, + NesterovATestTaskAll, + ::testing::Values(5, 10)); \ No newline at end of file diff --git a/tasks/mpi/example/func_tests/main.cpp b/tasks/mpi/example/func_tests/main.cpp index 666b471eb..905eef6f7 100644 --- a/tasks/mpi/example/func_tests/main.cpp +++ b/tasks/mpi/example/func_tests/main.cpp @@ -11,49 +11,42 @@ #include "core/util/include/util.hpp" #include "mpi/example/include/ops_mpi.hpp" -TEST(nesterov_a_test_task_mpi, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATestTaskMPI : public ::testing::TestWithParam { + protected: + void SetUp() override { + std::ifstream test_file(ppc::util::GetAbsolutePath("mpi/example/data/test.txt")); + ASSERT_TRUE(test_file.is_open()) << "Failed to open input file"; + std::string line; + std::getline(test_file, line); + test_file.close(); + base_count = std::stoi(line); } - // Create Task - nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(in); - ASSERT_EQ(test_task_mpi.Validation(), true); - test_task_mpi.PreProcessing(); - test_task_mpi.Run(); - test_task_mpi.PostProcessing(); - - EXPECT_EQ(in, test_task_mpi.Get()); -} - -TEST(nesterov_a_test_task_mpi, test_matmul_100_from_file) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("mpi/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); + [[nodiscard]] size_t GetCount() const { + return static_cast(base_count * GetParam()); } - test_file.close(); - const size_t count = std::stoi(line); + int base_count = 0; +}; - // Create data - std::vector in(count * count, 0); +TEST_P(NesterovATestTaskMPI, MatmulFromFile) { + const size_t count = GetCount(); - for (size_t i = 0; i < count; i++) { + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { in[(i * count) + i] = 1; } - // Create Task nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(in); - ASSERT_EQ(test_task_mpi.Validation(), true); + ASSERT_TRUE(test_task_mpi.Validation()); test_task_mpi.PreProcessing(); test_task_mpi.Run(); test_task_mpi.PostProcessing(); EXPECT_EQ(in, test_task_mpi.Get()); } + +INSTANTIATE_TEST_SUITE_P( + FileMatrixTestsMPI, + NesterovATestTaskMPI, + ::testing::Values(0.5, 1.0)); diff --git a/tasks/omp/example/func_tests/main.cpp b/tasks/omp/example/func_tests/main.cpp index 6ae487a97..b21237015 100644 --- a/tasks/omp/example/func_tests/main.cpp +++ b/tasks/omp/example/func_tests/main.cpp @@ -11,47 +11,42 @@ #include "core/util/include/util.hpp" #include "omp/example/include/ops_omp.hpp" -TEST(nesterov_a_test_task_omp, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATestTaskOMP : public ::testing::TestWithParam { + protected: + void SetUp() override { + std::ifstream test_file(ppc::util::GetAbsolutePath("omp/example/data/test.txt")); + ASSERT_TRUE(test_file.is_open()) << "Failed to open input file"; + std::string line; + std::getline(test_file, line); + test_file.close(); + base_count = std::stoi(line); } - // Create Task - nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(in); - ASSERT_EQ(test_task_omp.Validation(), true); - test_task_omp.PreProcessing(); - test_task_omp.Run(); - test_task_omp.PostProcessing(); - EXPECT_EQ(in, test_task_omp.Get()); -} - -TEST(nesterov_a_test_task_omp, test_matmul_100_from_file) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("omp/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); + [[nodiscard]] size_t GetCount() const { + return static_cast(base_count * GetParam()); } - test_file.close(); - const size_t count = std::stoi(line); + int base_count = 0; +}; - // Create data - std::vector in(count * count, 0); +TEST_P(NesterovATestTaskOMP, MatmulFromFile) { + const size_t count = GetCount(); - for (size_t i = 0; i < count; i++) { + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { in[(i * count) + i] = 1; } - // Create Task nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(in); - ASSERT_EQ(test_task_omp.Validation(), true); + ASSERT_TRUE(test_task_omp.Validation()); test_task_omp.PreProcessing(); test_task_omp.Run(); test_task_omp.PostProcessing(); + EXPECT_EQ(in, test_task_omp.Get()); } + +INSTANTIATE_TEST_SUITE_P( + FileMatrixTestsOMP, + NesterovATestTaskOMP, + ::testing::Values(0.5, 1.0)); diff --git a/tasks/seq/example/func_tests/main.cpp b/tasks/seq/example/func_tests/main.cpp index 066d057c0..1e344266d 100644 --- a/tasks/seq/example/func_tests/main.cpp +++ b/tasks/seq/example/func_tests/main.cpp @@ -11,47 +11,41 @@ #include "core/util/include/util.hpp" #include "seq/example/include/ops_seq.hpp" -TEST(nesterov_a_test_task_seq, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATestTaskSeq : public ::testing::TestWithParam { + protected: + void SetUp() override { + std::ifstream test_file(ppc::util::GetAbsolutePath("seq/example/data/test.txt")); + ASSERT_TRUE(test_file.is_open()) << "Failed to open input file"; + std::string line; + std::getline(test_file, line); + test_file.close(); + base_count = std::stoi(line); } - // Create Task - nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(in); - ASSERT_EQ(test_task_sequential.Validation(), true); - test_task_sequential.PreProcessing(); - test_task_sequential.Run(); - test_task_sequential.PostProcessing(); - EXPECT_EQ(in, test_task_sequential.Get()); -} - -TEST(nesterov_a_test_task_seq, test_matmul_100_from_file) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("seq/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); + [[nodiscard]] size_t GetCount() const { + return static_cast(base_count * GetParam()); } - test_file.close(); - const size_t count = std::stoi(line); + int base_count = 0; +}; - // Create data - std::vector in(count * count, 0); +TEST_P(NesterovATestTaskSeq, MatmulFromFile) { + const size_t count = GetCount(); + std::vector in(count * count, 0); for (size_t i = 0; i < count; i++) { in[(i * count) + i] = 1; } - // Create Task nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(in); - ASSERT_EQ(test_task_sequential.Validation(), true); + ASSERT_TRUE(test_task_sequential.Validation()); test_task_sequential.PreProcessing(); test_task_sequential.Run(); test_task_sequential.PostProcessing(); EXPECT_EQ(in, test_task_sequential.Get()); } + +INSTANTIATE_TEST_SUITE_P( + FileMatrixTests, + NesterovATestTaskSeq, + ::testing::Values(0.5, 1.0)); diff --git a/tasks/stl/example/func_tests/main.cpp b/tasks/stl/example/func_tests/main.cpp index 5825054df..f04739485 100644 --- a/tasks/stl/example/func_tests/main.cpp +++ b/tasks/stl/example/func_tests/main.cpp @@ -11,47 +11,42 @@ #include "core/util/include/util.hpp" #include "stl/example/include/ops_stl.hpp" -TEST(nesterov_a_test_task_stl, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATestTaskSTL : public ::testing::TestWithParam { + protected: + void SetUp() override { + std::ifstream test_file(ppc::util::GetAbsolutePath("stl/example/data/test.txt")); + ASSERT_TRUE(test_file.is_open()) << "Failed to open input file"; + std::string line; + std::getline(test_file, line); + test_file.close(); + base_count = std::stoi(line); } - // Create Task - nesterov_a_test_task_stl::TestTaskSTL test_task_stl(in); - ASSERT_EQ(test_task_stl.Validation(), true); - test_task_stl.PreProcessing(); - test_task_stl.Run(); - test_task_stl.PostProcessing(); - EXPECT_EQ(in, test_task_stl.Get()); -} - -TEST(nesterov_a_test_task_stl, test_matmul_100_from_file) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("stl/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); + [[nodiscard]] size_t GetCount() const { + return static_cast(base_count * GetParam()); } - test_file.close(); - const size_t count = std::stoi(line); + int base_count = 0; +}; - // Create data - std::vector in(count * count, 0); +TEST_P(NesterovATestTaskSTL, MatmulFromFile) { + const size_t count = GetCount(); - for (size_t i = 0; i < count; i++) { + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { in[(i * count) + i] = 1; } - // Create Task nesterov_a_test_task_stl::TestTaskSTL test_task_stl(in); - ASSERT_EQ(test_task_stl.Validation(), true); + ASSERT_TRUE(test_task_stl.Validation()); test_task_stl.PreProcessing(); test_task_stl.Run(); test_task_stl.PostProcessing(); + EXPECT_EQ(in, test_task_stl.Get()); } + +INSTANTIATE_TEST_SUITE_P( + FileMatrixTestsSTL, + NesterovATestTaskSTL, + ::testing::Values(0.5, 1.0)); diff --git a/tasks/tbb/example/func_tests/main.cpp b/tasks/tbb/example/func_tests/main.cpp index c4b86a30b..1fd978e9c 100644 --- a/tasks/tbb/example/func_tests/main.cpp +++ b/tasks/tbb/example/func_tests/main.cpp @@ -11,47 +11,42 @@ #include "core/util/include/util.hpp" #include "tbb/example/include/ops_tbb.hpp" -TEST(nesterov_a_test_task_tbb, test_matmul_50) { - constexpr size_t kCount = 50; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATestTaskTBB : public ::testing::TestWithParam { + protected: + void SetUp() override { + std::ifstream test_file(ppc::util::GetAbsolutePath("tbb/example/data/test.txt")); + ASSERT_TRUE(test_file.is_open()) << "Failed to open input file"; + std::string line; + std::getline(test_file, line); + test_file.close(); + base_count = std::stoi(line); } - // Create Task - nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(in); - ASSERT_EQ(test_task_tbb.Validation(), true); - test_task_tbb.PreProcessing(); - test_task_tbb.Run(); - test_task_tbb.PostProcessing(); - EXPECT_EQ(in, test_task_tbb.Get()); -} - -TEST(nesterov_a_test_task_tbb, test_matmul_100_from_file) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("tbb/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); + [[nodiscard]] size_t GetCount() const { + return static_cast(base_count * GetParam()); } - test_file.close(); - const size_t count = std::stoi(line); + int base_count = 0; +}; - // Create data - std::vector in(count * count, 0); +TEST_P(NesterovATestTaskTBB, MatmulFromFile) { + const size_t count = GetCount(); - for (size_t i = 0; i < count; i++) { + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { in[(i * count) + i] = 1; } - // Create Task nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(in); - ASSERT_EQ(test_task_tbb.Validation(), true); + ASSERT_TRUE(test_task_tbb.Validation()); test_task_tbb.PreProcessing(); test_task_tbb.Run(); test_task_tbb.PostProcessing(); + EXPECT_EQ(in, test_task_tbb.Get()); } + +INSTANTIATE_TEST_SUITE_P( + FileMatrixTestsTBB, + NesterovATestTaskTBB, + ::testing::Values(0.5, 1.0)); From d254cdbd0a1c201a42a7e7333096f4137c695e2a Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 20:03:34 +0200 Subject: [PATCH 12/22] clang refactor --- tasks/all/example/func_tests/main.cpp | 5 +---- tasks/mpi/example/func_tests/main.cpp | 9 ++------- tasks/omp/example/func_tests/main.cpp | 9 ++------- tasks/seq/example/func_tests/main.cpp | 9 ++------- tasks/stl/example/func_tests/main.cpp | 9 ++------- tasks/tbb/example/func_tests/main.cpp | 9 ++------- 6 files changed, 11 insertions(+), 39 deletions(-) diff --git a/tasks/all/example/func_tests/main.cpp b/tasks/all/example/func_tests/main.cpp index d6b24c238..e0f2e24c6 100644 --- a/tasks/all/example/func_tests/main.cpp +++ b/tasks/all/example/func_tests/main.cpp @@ -46,7 +46,4 @@ TEST_P(NesterovATestTaskAll, MatmulFromPic) { EXPECT_EQ(in, test_task_all.Get()); } -INSTANTIATE_TEST_SUITE_P( - PicMatrixTests, - NesterovATestTaskAll, - ::testing::Values(5, 10)); \ No newline at end of file +INSTANTIATE_TEST_SUITE_P(PicMatrixTests, NesterovATestTaskAll, ::testing::Values(5, 10)); \ No newline at end of file diff --git a/tasks/mpi/example/func_tests/main.cpp b/tasks/mpi/example/func_tests/main.cpp index 905eef6f7..0339b7861 100644 --- a/tasks/mpi/example/func_tests/main.cpp +++ b/tasks/mpi/example/func_tests/main.cpp @@ -22,9 +22,7 @@ class NesterovATestTaskMPI : public ::testing::TestWithParam { base_count = std::stoi(line); } - [[nodiscard]] size_t GetCount() const { - return static_cast(base_count * GetParam()); - } + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } int base_count = 0; }; @@ -46,7 +44,4 @@ TEST_P(NesterovATestTaskMPI, MatmulFromFile) { EXPECT_EQ(in, test_task_mpi.Get()); } -INSTANTIATE_TEST_SUITE_P( - FileMatrixTestsMPI, - NesterovATestTaskMPI, - ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P(FileMatrixTestsMPI, NesterovATestTaskMPI, ::testing::Values(0.5, 1.0)); diff --git a/tasks/omp/example/func_tests/main.cpp b/tasks/omp/example/func_tests/main.cpp index b21237015..1457fbbff 100644 --- a/tasks/omp/example/func_tests/main.cpp +++ b/tasks/omp/example/func_tests/main.cpp @@ -22,9 +22,7 @@ class NesterovATestTaskOMP : public ::testing::TestWithParam { base_count = std::stoi(line); } - [[nodiscard]] size_t GetCount() const { - return static_cast(base_count * GetParam()); - } + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } int base_count = 0; }; @@ -46,7 +44,4 @@ TEST_P(NesterovATestTaskOMP, MatmulFromFile) { EXPECT_EQ(in, test_task_omp.Get()); } -INSTANTIATE_TEST_SUITE_P( - FileMatrixTestsOMP, - NesterovATestTaskOMP, - ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P(FileMatrixTestsOMP, NesterovATestTaskOMP, ::testing::Values(0.5, 1.0)); diff --git a/tasks/seq/example/func_tests/main.cpp b/tasks/seq/example/func_tests/main.cpp index 1e344266d..c9a90ce88 100644 --- a/tasks/seq/example/func_tests/main.cpp +++ b/tasks/seq/example/func_tests/main.cpp @@ -22,9 +22,7 @@ class NesterovATestTaskSeq : public ::testing::TestWithParam { base_count = std::stoi(line); } - [[nodiscard]] size_t GetCount() const { - return static_cast(base_count * GetParam()); - } + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } int base_count = 0; }; @@ -45,7 +43,4 @@ TEST_P(NesterovATestTaskSeq, MatmulFromFile) { EXPECT_EQ(in, test_task_sequential.Get()); } -INSTANTIATE_TEST_SUITE_P( - FileMatrixTests, - NesterovATestTaskSeq, - ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P(FileMatrixTests, NesterovATestTaskSeq, ::testing::Values(0.5, 1.0)); diff --git a/tasks/stl/example/func_tests/main.cpp b/tasks/stl/example/func_tests/main.cpp index f04739485..2a7cd54c5 100644 --- a/tasks/stl/example/func_tests/main.cpp +++ b/tasks/stl/example/func_tests/main.cpp @@ -22,9 +22,7 @@ class NesterovATestTaskSTL : public ::testing::TestWithParam { base_count = std::stoi(line); } - [[nodiscard]] size_t GetCount() const { - return static_cast(base_count * GetParam()); - } + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } int base_count = 0; }; @@ -46,7 +44,4 @@ TEST_P(NesterovATestTaskSTL, MatmulFromFile) { EXPECT_EQ(in, test_task_stl.Get()); } -INSTANTIATE_TEST_SUITE_P( - FileMatrixTestsSTL, - NesterovATestTaskSTL, - ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P(FileMatrixTestsSTL, NesterovATestTaskSTL, ::testing::Values(0.5, 1.0)); diff --git a/tasks/tbb/example/func_tests/main.cpp b/tasks/tbb/example/func_tests/main.cpp index 1fd978e9c..60bfb2ca3 100644 --- a/tasks/tbb/example/func_tests/main.cpp +++ b/tasks/tbb/example/func_tests/main.cpp @@ -22,9 +22,7 @@ class NesterovATestTaskTBB : public ::testing::TestWithParam { base_count = std::stoi(line); } - [[nodiscard]] size_t GetCount() const { - return static_cast(base_count * GetParam()); - } + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } int base_count = 0; }; @@ -46,7 +44,4 @@ TEST_P(NesterovATestTaskTBB, MatmulFromFile) { EXPECT_EQ(in, test_task_tbb.Get()); } -INSTANTIATE_TEST_SUITE_P( - FileMatrixTestsTBB, - NesterovATestTaskTBB, - ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P(FileMatrixTestsTBB, NesterovATestTaskTBB, ::testing::Values(0.5, 1.0)); From cb553bf613fa5a6d6f86166c403298ce4064cea6 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Wed, 14 May 2025 21:22:54 +0200 Subject: [PATCH 13/22] refactor perf tests --- tasks/all/example/perf_tests/main.cpp | 60 +++++++++++ tasks/all/example/perf_tests/perf_all.cpp | 89 ---------------- tasks/mpi/example/perf_tests/main.cpp | 118 +++++++++------------- tasks/omp/example/perf_tests/main.cpp | 105 ++++++++----------- tasks/seq/example/perf_tests/main.cpp | 105 ++++++++----------- tasks/stl/example/perf_tests/main.cpp | 104 ++++++++----------- tasks/tbb/example/perf_tests/main.cpp | 102 ++++++++----------- 7 files changed, 279 insertions(+), 404 deletions(-) create mode 100644 tasks/all/example/perf_tests/main.cpp delete mode 100644 tasks/all/example/perf_tests/perf_all.cpp diff --git a/tasks/all/example/perf_tests/main.cpp b/tasks/all/example/perf_tests/main.cpp new file mode 100644 index 000000000..c5dfa3f17 --- /dev/null +++ b/tasks/all/example/perf_tests/main.cpp @@ -0,0 +1,60 @@ +#include +#include + +#include +#include +#include +#include +#include + +#include "all/example/include/ops_all.hpp" +#include "core/perf/include/perf.hpp" +#include "core/task/include/task.hpp" + +class NesterovAllRunTest : public ::testing::TestWithParam { + protected: + static constexpr int kCount = 400; + std::vector input_data; + + void SetUp() override { + input_data.assign(kCount * kCount, 0); + for (int i = 0; i < kCount; ++i) { + input_data[(i * kCount) + i] = 1; + } + } + + void ExecuteTest(ppc::core::PerfResults::TypeOfRunning mode) { + auto task = std::make_shared(input_data); + + ppc::core::PerfAttr perf_attr; + const auto t0 = std::chrono::high_resolution_clock::now(); + perf_attr.current_timer = [&] { + auto now = std::chrono::high_resolution_clock::now(); + auto ns = std::chrono::duration_cast(now - t0).count(); + return static_cast(ns) * 1e-9; + }; + + ppc::core::PerfResults perf_results; + ppc::core::Perf perf(task); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf.PipelineRun(perf_attr, perf_results); + } else { + perf.TaskRun(perf_attr, perf_results); + } + + int rank = -1; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + if (rank == 0) { + ppc::core::Perf::PrintPerfStatistic(perf_results); + } + + ASSERT_EQ(input_data, task->Get()); + } +}; + +TEST_P(NesterovAllRunTest, RunModes) { ExecuteTest(GetParam()); } + +INSTANTIATE_TEST_SUITE_P(RunModeTests, NesterovAllRunTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/all/example/perf_tests/perf_all.cpp b/tasks/all/example/perf_tests/perf_all.cpp deleted file mode 100644 index 6626a6774..000000000 --- a/tasks/all/example/perf_tests/perf_all.cpp +++ /dev/null @@ -1,89 +0,0 @@ -#include -#include - -#include -#include -#include -#include -#include - -#include "all/example/include/ops_all.hpp" -#include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" - -TEST(nesterov_a_test_task_all, test_pipeline_run) { - constexpr int kCount = 400; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_all = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_all); - perf_analyzer.PipelineRun(perf_attr, perf_results); - // Create Perf analyzer - int rank = -1; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); - } - - ASSERT_EQ(in, test_task_all->Get()); -} - -TEST(nesterov_a_test_task_all, test_task_run) { - constexpr int kCount = 400; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_all = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_all); - perf_analyzer.TaskRun(perf_attr, perf_results); - - // Create Perf analyzer - int rank = -1; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); - } - - ASSERT_EQ(in, test_task_all->Get()); -} diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index a5979e9b5..8cae54722 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -11,77 +11,53 @@ #include "core/task/include/task.hpp" #include "mpi/example/include/ops_mpi.hpp" -TEST(nesterov_a_test_task_mpi, test_pipeline_run) { - constexpr int kCount = 500; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_mpi = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - ppc::core::Perf perf_analyzer(test_task_mpi); - perf_analyzer.PipelineRun(perf_attr, perf_results); - // Create Perf analyzer - int rank = -1; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); - } - - ASSERT_EQ(in, test_task_mpi->Get()); -} - -TEST(nesterov_a_test_task_mpi, test_task_run) { - constexpr int kCount = 500; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovATaskMPITest : public ::testing::TestWithParam { + protected: + static void RunTest(ppc::core::PerfResults::TypeOfRunning mode) { + constexpr int kCount = 500; + + // Create data + std::vector in(kCount * kCount, 0); + for (size_t i = 0; i < kCount; i++) { + in[(i * kCount) + i] = 1; + } + + // Create Task + auto test_task_mpi = std::make_shared(in); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + 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(current_time_point - t0).count(); + return static_cast(duration) * 1e-9; + }; + + // Create and init perf results + ppc::core::PerfResults perf_results; + + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_mpi); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr, perf_results); + } else { + perf_analyzer.TaskRun(perf_attr, perf_results); + } + + int rank = -1; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + if (rank == 0) { + ppc::core::Perf::PrintPerfStatistic(perf_results); + } + + ASSERT_EQ(in, test_task_mpi->Get()); } +}; - // Create Task - auto test_task_mpi = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_mpi); - perf_analyzer.TaskRun(perf_attr, perf_results); - // Create Perf analyzer - int rank = -1; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); - } +TEST_P(NesterovATaskMPITest, RunModes) { RunTest(GetParam()); } - ASSERT_EQ(in, test_task_mpi->Get()); -} +INSTANTIATE_TEST_SUITE_P(NesterovATests, NesterovATaskMPITest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/omp/example/perf_tests/main.cpp b/tasks/omp/example/perf_tests/main.cpp index b30fdf1c7..77d6190b9 100644 --- a/tasks/omp/example/perf_tests/main.cpp +++ b/tasks/omp/example/perf_tests/main.cpp @@ -10,68 +10,49 @@ #include "core/task/include/task.hpp" #include "omp/example/include/ops_omp.hpp" -TEST(nesterov_a_test_task_omp, test_pipeline_run) { - constexpr int kCount = 300; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_omp = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_omp); - perf_analyzer.PipelineRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - - ASSERT_EQ(in, test_task_omp->Get()); -} - -TEST(nesterov_a_test_task_omp, test_task_run) { - constexpr int kCount = 300; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovTaskOMPTest : public ::testing::TestWithParam { + protected: + static void RunTest(ppc::core::PerfResults::TypeOfRunning mode) { + constexpr int kCount = 300; + + // Create data + std::vector in(kCount * kCount, 0); + for (size_t i = 0; i < kCount; i++) { + in[(i * kCount) + i] = 1; + } + + // Create Task + auto test_task_omp = std::make_shared(in); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + 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(current_time_point - t0).count(); + return static_cast(duration) * 1e-9; + }; + + // Create and init perf results + ppc::core::PerfResults perf_results; + + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_omp); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr, perf_results); + } else { + perf_analyzer.TaskRun(perf_attr, perf_results); + } + + ppc::core::Perf::PrintPerfStatistic(perf_results); + + ASSERT_EQ(in, test_task_omp->Get()); } +}; - // Create Task - auto test_task_omp = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_omp); - perf_analyzer.TaskRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); +TEST_P(NesterovTaskOMPTest, RunModes) { RunTest(GetParam()); } - ASSERT_EQ(in, test_task_omp->Get()); -} +INSTANTIATE_TEST_SUITE_P(NesterovOMPTests, NesterovTaskOMPTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/seq/example/perf_tests/main.cpp b/tasks/seq/example/perf_tests/main.cpp index 13a5b2782..0dc0bffdb 100644 --- a/tasks/seq/example/perf_tests/main.cpp +++ b/tasks/seq/example/perf_tests/main.cpp @@ -10,68 +10,49 @@ #include "core/task/include/task.hpp" #include "seq/example/include/ops_seq.hpp" -TEST(nesterov_a_test_task_seq, test_pipeline_run) { - constexpr int kCount = 500; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_sequential = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_sequential); - perf_analyzer.PipelineRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - - ASSERT_EQ(in, test_task_sequential->Get()); -} - -TEST(nesterov_a_test_task_seq, test_task_run) { - constexpr int kCount = 500; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovTaskSeqTest : public ::testing::TestWithParam { + protected: + static void RunTest(ppc::core::PerfResults::TypeOfRunning mode) { + constexpr int kCount = 500; + + // Create data + std::vector in(kCount * kCount, 0); + for (size_t i = 0; i < kCount; i++) { + in[(i * kCount) + i] = 1; + } + + // Create Task + auto test_task_sequential = std::make_shared(in); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + 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(current_time_point - t0).count(); + return static_cast(duration) * 1e-9; + }; + + // Create and init perf results + ppc::core::PerfResults perf_results; + + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_sequential); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr, perf_results); + } else { + perf_analyzer.TaskRun(perf_attr, perf_results); + } + + ppc::core::Perf::PrintPerfStatistic(perf_results); + + ASSERT_EQ(in, test_task_sequential->Get()); } +}; - // Create Task - auto test_task_sequential = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_sequential); - perf_analyzer.TaskRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); +TEST_P(NesterovTaskSeqTest, RunModes) { RunTest(GetParam()); } - ASSERT_EQ(in, test_task_sequential->Get()); -} +INSTANTIATE_TEST_SUITE_P(NesterovSeqTests, NesterovTaskSeqTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/stl/example/perf_tests/main.cpp b/tasks/stl/example/perf_tests/main.cpp index a6b84a7fd..6b89159a6 100644 --- a/tasks/stl/example/perf_tests/main.cpp +++ b/tasks/stl/example/perf_tests/main.cpp @@ -10,67 +10,49 @@ #include "core/task/include/task.hpp" #include "stl/example/include/ops_stl.hpp" -TEST(nesterov_a_test_task_stl, test_pipeline_run) { - constexpr int kCount = 450; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovTaskSTLTest : public ::testing::TestWithParam { + protected: + static void RunTest(ppc::core::PerfResults::TypeOfRunning mode) { + constexpr int kCount = 450; + + // Create data + std::vector in(kCount * kCount, 0); + for (size_t i = 0; i < kCount; i++) { + in[(i * kCount) + i] = 1; + } + + // Create Task + auto test_task_stl = std::make_shared(in); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + 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(current_time_point - t0).count(); + return static_cast(duration) * 1e-9; + }; + + // Create and init perf results + ppc::core::PerfResults perf_results; + + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_stl); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr, perf_results); + } else { + perf_analyzer.TaskRun(perf_attr, perf_results); + } + + ppc::core::Perf::PrintPerfStatistic(perf_results); + + ASSERT_EQ(in, test_task_stl->Get()); } +}; - // Create Task - auto test_task_sequential = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_sequential); - perf_analyzer.PipelineRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - - ASSERT_EQ(in, test_task_sequential->Get()); -} - -TEST(nesterov_a_test_task_stl, test_task_run) { - constexpr int kCount = 450; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_sequential = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; +TEST_P(NesterovTaskSTLTest, RunModes) { RunTest(GetParam()); } - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_sequential); - perf_analyzer.TaskRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, test_task_sequential->Get()); -} +INSTANTIATE_TEST_SUITE_P(NesterovSTLTests, NesterovTaskSTLTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/tbb/example/perf_tests/main.cpp b/tasks/tbb/example/perf_tests/main.cpp index 7779dcea9..b0943cffd 100644 --- a/tasks/tbb/example/perf_tests/main.cpp +++ b/tasks/tbb/example/perf_tests/main.cpp @@ -10,65 +10,49 @@ #include "core/task/include/task.hpp" #include "tbb/example/include/ops_tbb.hpp" -TEST(nesterov_a_test_task_tbb, test_pipeline_run) { - constexpr int kCount = 450; - - // Create data - std::vector in(kCount * kCount, 0); - - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; +class NesterovTaskTBBTest : public ::testing::TestWithParam { + protected: + static void RunTest(ppc::core::PerfResults::TypeOfRunning mode) { + constexpr int kCount = 450; + + // Create data + std::vector in(kCount * kCount, 0); + for (size_t i = 0; i < kCount; i++) { + in[(i * kCount) + i] = 1; + } + + // Create Task + auto test_task_tbb = std::make_shared(in); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + 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(current_time_point - t0).count(); + return static_cast(duration) * 1e-9; + }; + + // Create and init perf results + ppc::core::PerfResults perf_results; + + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_tbb); + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr, perf_results); + } else { + perf_analyzer.TaskRun(perf_attr, perf_results); + } + + ppc::core::Perf::PrintPerfStatistic(perf_results); + + ASSERT_EQ(in, test_task_tbb->Get()); } +}; - // Create Task - auto test_task_tbb = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_tbb); - perf_analyzer.PipelineRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, test_task_tbb->Get()); -} - -TEST(nesterov_a_test_task_tbb, test_task_run) { - constexpr int kCount = 450; - - // Create data - std::vector in(kCount * kCount, 0); - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } - - // Create Task - auto test_task_tbb = std::make_shared(in); - - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - 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(current_time_point - t0).count(); - return static_cast(duration) * 1e-9; - }; - - // Create and init perf results - ppc::core::PerfResults perf_results; +TEST_P(NesterovTaskTBBTest, RunModes) { RunTest(GetParam()); } - // Create Perf analyzer - auto perf_analyzer = std::make_shared(test_task_tbb); - perf_analyzer->TaskRun(perf_attr, perf_results); - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_EQ(in, test_task_tbb->Get()); -} +INSTANTIATE_TEST_SUITE_P(NesterovTBBTests, NesterovTaskTBBTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); From 343644a7276ed293cb543c438b9efc86baed7c5d Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Thu, 15 May 2025 11:26:01 +0200 Subject: [PATCH 14/22] fix clang tidy --- modules/core/util/include/util.hpp | 4 ++++ tasks/all/example/func_tests/main.cpp | 5 +---- tasks/all/example/perf_tests/main.cpp | 10 ++++------ tasks/mpi/example/func_tests/main.cpp | 3 +-- tasks/mpi/example/perf_tests/main.cpp | 8 ++++---- tasks/omp/example/func_tests/main.cpp | 2 +- tasks/omp/example/perf_tests/main.cpp | 8 ++++---- tasks/seq/example/func_tests/main.cpp | 2 +- tasks/seq/example/perf_tests/main.cpp | 8 ++++---- tasks/stl/example/func_tests/main.cpp | 2 +- tasks/stl/example/perf_tests/main.cpp | 8 ++++---- tasks/tbb/example/func_tests/main.cpp | 2 +- tasks/tbb/example/perf_tests/main.cpp | 8 ++++---- 13 files changed, 34 insertions(+), 36 deletions(-) diff --git a/modules/core/util/include/util.hpp b/modules/core/util/include/util.hpp index 6a5db269f..c1d74e4e1 100644 --- a/modules/core/util/include/util.hpp +++ b/modules/core/util/include/util.hpp @@ -1,6 +1,10 @@ #pragma once #include +// NOLINTNEXTLINE +#define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \ + INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) // NOLINT + namespace ppc::util { std::string GetAbsolutePath(const std::string &relative_path); diff --git a/tasks/all/example/func_tests/main.cpp b/tasks/all/example/func_tests/main.cpp index e0f2e24c6..e485fea43 100644 --- a/tasks/all/example/func_tests/main.cpp +++ b/tasks/all/example/func_tests/main.cpp @@ -1,14 +1,11 @@ #include -#include #include -#include #include #include #include #include "all/example/include/ops_all.hpp" -#include "core/task/include/task.hpp" #include "core/util/include/util.hpp" class NesterovATestTaskAll : public ::testing::TestWithParam { @@ -46,4 +43,4 @@ TEST_P(NesterovATestTaskAll, MatmulFromPic) { EXPECT_EQ(in, test_task_all.Get()); } -INSTANTIATE_TEST_SUITE_P(PicMatrixTests, NesterovATestTaskAll, ::testing::Values(5, 10)); \ No newline at end of file +INSTANTIATE_TEST_SUITE_P_NOLINT(PicMatrixTests, NesterovATestTaskAll, ::testing::Values(5, 10)); diff --git a/tasks/all/example/perf_tests/main.cpp b/tasks/all/example/perf_tests/main.cpp index c5dfa3f17..3a33111ab 100644 --- a/tasks/all/example/perf_tests/main.cpp +++ b/tasks/all/example/perf_tests/main.cpp @@ -2,14 +2,12 @@ #include #include -#include -#include #include #include #include "all/example/include/ops_all.hpp" #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" class NesterovAllRunTest : public ::testing::TestWithParam { protected: @@ -55,6 +53,6 @@ class NesterovAllRunTest : public ::testing::TestWithParam #include -#include "core/task/include/task.hpp" #include "core/util/include/util.hpp" #include "mpi/example/include/ops_mpi.hpp" @@ -44,4 +43,4 @@ TEST_P(NesterovATestTaskMPI, MatmulFromFile) { EXPECT_EQ(in, test_task_mpi.Get()); } -INSTANTIATE_TEST_SUITE_P(FileMatrixTestsMPI, NesterovATestTaskMPI, ::testing::Values(0.5, 1.0)); +INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTestsMPI, NesterovATestTaskMPI, ::testing::Values(0.5, 1.0)); diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index 8cae54722..1cf8827a0 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -8,7 +8,7 @@ #include #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" #include "mpi/example/include/ops_mpi.hpp" class NesterovATaskMPITest : public ::testing::TestWithParam { @@ -58,6 +58,6 @@ class NesterovATaskMPITest : public ::testing::TestWithParam #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" #include "omp/example/include/ops_omp.hpp" class NesterovTaskOMPTest : public ::testing::TestWithParam { @@ -53,6 +53,6 @@ class NesterovTaskOMPTest : public ::testing::TestWithParam #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" #include "seq/example/include/ops_seq.hpp" class NesterovTaskSeqTest : public ::testing::TestWithParam { @@ -53,6 +53,6 @@ class NesterovTaskSeqTest : public ::testing::TestWithParam #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" #include "stl/example/include/ops_stl.hpp" class NesterovTaskSTLTest : public ::testing::TestWithParam { @@ -53,6 +53,6 @@ class NesterovTaskSTLTest : public ::testing::TestWithParam #include "core/perf/include/perf.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.hpp" #include "tbb/example/include/ops_tbb.hpp" class NesterovTaskTBBTest : public ::testing::TestWithParam { @@ -53,6 +53,6 @@ class NesterovTaskTBBTest : public ::testing::TestWithParam Date: Thu, 15 May 2025 12:24:16 +0200 Subject: [PATCH 15/22] fix script --- scripts/run_perf_counter.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/scripts/run_perf_counter.py b/scripts/run_perf_counter.py index efb8358bb..f8840fcbe 100644 --- a/scripts/run_perf_counter.py +++ b/scripts/run_perf_counter.py @@ -38,11 +38,11 @@ def run_script(_script_path): if __name__ == "__main__": args_dict = init_cmd_args() tests_list = run_script(Path(get_project_path()) / "scripts/run_tests.py") - tests_number = len(tests_list) + tests_number = int((len(tests_list) / 3) * 2) - pattern = r".*all\.|.*_mpi\.|.*_omp\.|.*_seq\.|.*_stl\.|.*_tbb\." + pattern = r".*GetParam().*" test_matches = [test_name for test_name in tests_list if re.match(pattern, test_name)] - required_tests_number = (args_dict["required_tests_number"] + 1) * len(test_matches) + required_tests_number = int((args_dict["required_tests_number"] + 1) * len(test_matches) / 3) if tests_number != required_tests_number: raise Exception(f"Count of all tests {tests_number} != count of required tests {required_tests_number}.") From a260fc0c3f778666d9ee5a496e26c80a357c19dd Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Thu, 15 May 2025 12:55:22 +0200 Subject: [PATCH 16/22] fix coverage --- tasks/all/example/include/ops_all.hpp | 2 +- tasks/all/example/src/ops_all.cpp | 2 ++ tasks/mpi/example/include/ops_mpi.hpp | 2 +- tasks/mpi/example/src/ops_mpi.cpp | 2 ++ tasks/omp/example/include/ops_omp.hpp | 2 +- tasks/omp/example/src/ops_omp.cpp | 2 ++ tasks/seq/example/include/ops_seq.hpp | 2 +- tasks/seq/example/src/ops_seq.cpp | 2 ++ tasks/stl/example/include/ops_stl.hpp | 2 +- tasks/stl/example/src/ops_stl.cpp | 2 ++ tasks/tbb/example/include/ops_tbb.hpp | 2 +- tasks/tbb/example/src/ops_tbb.cpp | 2 ++ 12 files changed, 18 insertions(+), 6 deletions(-) diff --git a/tasks/all/example/include/ops_all.hpp b/tasks/all/example/include/ops_all.hpp index 49f589a57..8fcd3ef38 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -14,7 +14,7 @@ class TestTaskALL : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index cdcb3a8fa..6675cb3a3 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -69,3 +69,5 @@ bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { } bool nesterov_a_test_task_all::TestTaskALL::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_all::TestTaskALL::Get() { return output_; } diff --git a/tasks/mpi/example/include/ops_mpi.hpp b/tasks/mpi/example/include/ops_mpi.hpp index b7e88e54a..9d007ffc5 100644 --- a/tasks/mpi/example/include/ops_mpi.hpp +++ b/tasks/mpi/example/include/ops_mpi.hpp @@ -14,7 +14,7 @@ class TestTaskMPI : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/mpi/example/src/ops_mpi.cpp b/tasks/mpi/example/src/ops_mpi.cpp index c74286652..f668d8847 100644 --- a/tasks/mpi/example/src/ops_mpi.cpp +++ b/tasks/mpi/example/src/ops_mpi.cpp @@ -56,3 +56,5 @@ void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyColumnMajor() { } bool nesterov_a_test_task_mpi::TestTaskMPI::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_mpi::TestTaskMPI::Get() { return output_; } diff --git a/tasks/omp/example/include/ops_omp.hpp b/tasks/omp/example/include/ops_omp.hpp index 607297f29..87209c39e 100644 --- a/tasks/omp/example/include/ops_omp.hpp +++ b/tasks/omp/example/include/ops_omp.hpp @@ -14,7 +14,7 @@ class TestTaskOpenMP : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/omp/example/src/ops_omp.cpp b/tasks/omp/example/src/ops_omp.cpp index 910efc28a..380be6aa8 100644 --- a/tasks/omp/example/src/ops_omp.cpp +++ b/tasks/omp/example/src/ops_omp.cpp @@ -35,3 +35,5 @@ bool nesterov_a_test_task_omp::TestTaskOpenMP::RunImpl() { } bool nesterov_a_test_task_omp::TestTaskOpenMP::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_omp::TestTaskOpenMP::Get() { return output_; } diff --git a/tasks/seq/example/include/ops_seq.hpp b/tasks/seq/example/include/ops_seq.hpp index be9e0f18c..f03fc7fb8 100644 --- a/tasks/seq/example/include/ops_seq.hpp +++ b/tasks/seq/example/include/ops_seq.hpp @@ -14,7 +14,7 @@ class TestTaskSequential : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/seq/example/src/ops_seq.cpp b/tasks/seq/example/src/ops_seq.cpp index 86e9893c0..40df2e006 100644 --- a/tasks/seq/example/src/ops_seq.cpp +++ b/tasks/seq/example/src/ops_seq.cpp @@ -28,3 +28,5 @@ bool nesterov_a_test_task_seq::TestTaskSequential::RunImpl() { } bool nesterov_a_test_task_seq::TestTaskSequential::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_seq::TestTaskSequential::Get() { return output_; } diff --git a/tasks/stl/example/include/ops_stl.hpp b/tasks/stl/example/include/ops_stl.hpp index dcd9b386c..1461d8ca2 100644 --- a/tasks/stl/example/include/ops_stl.hpp +++ b/tasks/stl/example/include/ops_stl.hpp @@ -14,7 +14,7 @@ class TestTaskSTL : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/stl/example/src/ops_stl.cpp b/tasks/stl/example/src/ops_stl.cpp index a6682e502..608360d54 100644 --- a/tasks/stl/example/src/ops_stl.cpp +++ b/tasks/stl/example/src/ops_stl.cpp @@ -43,3 +43,5 @@ bool nesterov_a_test_task_stl::TestTaskSTL::RunImpl() { } bool nesterov_a_test_task_stl::TestTaskSTL::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_stl::TestTaskSTL::Get() { return output_; } diff --git a/tasks/tbb/example/include/ops_tbb.hpp b/tasks/tbb/example/include/ops_tbb.hpp index 33935d181..4df85defb 100644 --- a/tasks/tbb/example/include/ops_tbb.hpp +++ b/tasks/tbb/example/include/ops_tbb.hpp @@ -14,7 +14,7 @@ class TestTaskTBB : public ppc::core::Task { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - std::vector Get() { return output_; } + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/tbb/example/src/ops_tbb.cpp b/tasks/tbb/example/src/ops_tbb.cpp index b4e735ced..3f233a701 100644 --- a/tasks/tbb/example/src/ops_tbb.cpp +++ b/tasks/tbb/example/src/ops_tbb.cpp @@ -47,3 +47,5 @@ bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { } bool nesterov_a_test_task_tbb::TestTaskTBB::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_tbb::TestTaskTBB::Get() { return output_; } From 79452699fe9e4d22865852d3db21ac20d1d6a96a Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Thu, 15 May 2025 14:57:11 +0200 Subject: [PATCH 17/22] increase coverage --- tasks/all/example/func_tests/main.cpp | 28 +++++++++++++++++++++++++++ tasks/all/example/include/ops_all.hpp | 5 ++++- tasks/all/example/src/ops_all.cpp | 26 +++++++++++++------------ tasks/mpi/example/func_tests/main.cpp | 28 +++++++++++++++++++++++++++ tasks/mpi/example/include/ops_mpi.hpp | 7 ++++--- tasks/mpi/example/src/ops_mpi.cpp | 24 +++++++++++------------ 6 files changed, 90 insertions(+), 28 deletions(-) diff --git a/tasks/all/example/func_tests/main.cpp b/tasks/all/example/func_tests/main.cpp index e485fea43..b506003ab 100644 --- a/tasks/all/example/func_tests/main.cpp +++ b/tasks/all/example/func_tests/main.cpp @@ -43,4 +43,32 @@ TEST_P(NesterovATestTaskAll, MatmulFromPic) { EXPECT_EQ(in, test_task_all.Get()); } +TEST_P(NesterovATestTaskAll, MatMulUtilFromPic) { + int divider = GetParam(); + const int k_count = (width + height) / divider; + + std::vector in(k_count * k_count, 0); + for (int i = 0; i < k_count; i++) { + in[(i * k_count) + i] = 1; + } + std::vector out(k_count * k_count, 0); + nesterov_a_test_task_all::MatMul(in, static_cast(k_count), out); + + EXPECT_EQ(in, out); +} + +TEST_P(NesterovATestTaskAll, MatMulTBBUtilFromPic) { + int divider = GetParam(); + const int k_count = (width + height) / divider; + + std::vector in(k_count * k_count, 0); + for (int i = 0; i < k_count; i++) { + in[(i * k_count) + i] = 1; + } + std::vector out(k_count * k_count, 0); + nesterov_a_test_task_all::MatMulTBB(in, static_cast(k_count), out); + + EXPECT_EQ(in, out); +} + INSTANTIATE_TEST_SUITE_P_NOLINT(PicMatrixTests, NesterovATestTaskAll, ::testing::Values(5, 10)); diff --git a/tasks/all/example/include/ops_all.hpp b/tasks/all/example/include/ops_all.hpp index 8fcd3ef38..fab463ee8 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -7,9 +7,12 @@ namespace nesterov_a_test_task_all { +void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_vec); +void MatMulTBB(const std::vector &in_vec, int rc_size, std::vector &out_vec); + class TestTaskALL : public ppc::core::Task { public: - explicit TestTaskALL(const std::vector& in) : input_(in) {} + explicit TestTaskALL(const std::vector &in) : input_(in) {} bool ValidationImpl() override; bool PreProcessingImpl() override; bool RunImpl() override; diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index 6675cb3a3..1e58f2ee4 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -12,8 +12,7 @@ #include "oneapi/tbb/task_arena.h" #include "oneapi/tbb/task_group.h" -namespace { -void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_vec) { +void nesterov_a_test_task_all::MatMul(const std::vector &in_vec, int rc_size, std::vector &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; @@ -23,7 +22,17 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v } } } -} // namespace + +void nesterov_a_test_task_all::MatMulTBB(const std::vector &in_vec, int rc_size, std::vector &out_vec) { + oneapi::tbb::task_arena arena(1); + arena.execute([&] { + tbb::task_group tg; + for (int i = 0; i < ppc::util::GetPPCNumThreads(); ++i) { + tg.run([&] { MatMul(in_vec, rc_size, out_vec); }); + } + tg.wait(); + }); +} bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { auto sqrt_size = static_cast(std::sqrt(input_.size())); @@ -44,17 +53,10 @@ bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { #pragma omp parallel default(none) { #pragma omp critical - { MatMul(input_, rc_size_, output_); } + MatMul(input_, rc_size_, output_); } } else { - oneapi::tbb::task_arena arena(1); - arena.execute([&] { - tbb::task_group tg; - for (int i = 0; i < ppc::util::GetPPCNumThreads(); ++i) { - tg.run([&] { MatMul(input_, rc_size_, output_); }); - } - tg.wait(); - }); + MatMulTBB(input_, rc_size_, output_); } const int num_threads = ppc::util::GetPPCNumThreads(); diff --git a/tasks/mpi/example/func_tests/main.cpp b/tasks/mpi/example/func_tests/main.cpp index be812d191..493083f03 100644 --- a/tasks/mpi/example/func_tests/main.cpp +++ b/tasks/mpi/example/func_tests/main.cpp @@ -43,4 +43,32 @@ TEST_P(NesterovATestTaskMPI, MatmulFromFile) { EXPECT_EQ(in, test_task_mpi.Get()); } +TEST_P(NesterovATestTaskMPI, MultiplyRowMajorUtilTestFromFile) { + const size_t count = GetCount(); + + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { + in[(i * count) + i] = 1; + } + + std::vector out(count * count, 0); + nesterov_a_test_task_mpi::MultiplyRowMajor(in, out, static_cast(count)); + + EXPECT_EQ(in, out); +} + +TEST_P(NesterovATestTaskMPI, MultiplyColumnMajorUtilTestFromFile) { + const size_t count = GetCount(); + + std::vector in(count * count, 0); + for (size_t i = 0; i < count; ++i) { + in[(i * count) + i] = 1; + } + + std::vector out(count * count, 0); + nesterov_a_test_task_mpi::MultiplyColumnMajor(in, out, static_cast(count)); + + EXPECT_EQ(in, out); +} + INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTestsMPI, NesterovATestTaskMPI, ::testing::Values(0.5, 1.0)); diff --git a/tasks/mpi/example/include/ops_mpi.hpp b/tasks/mpi/example/include/ops_mpi.hpp index 9d007ffc5..31b1f0424 100644 --- a/tasks/mpi/example/include/ops_mpi.hpp +++ b/tasks/mpi/example/include/ops_mpi.hpp @@ -7,9 +7,12 @@ namespace nesterov_a_test_task_mpi { +void MultiplyRowMajor(const std::vector &in, std::vector &out, int rc_size); +void MultiplyColumnMajor(const std::vector &in, std::vector &out, int rc_size); + class TestTaskMPI : public ppc::core::Task { public: - explicit TestTaskMPI(const std::vector& in) : input_(in) {} + explicit TestTaskMPI(const std::vector &in) : input_(in) {} bool ValidationImpl() override; bool PreProcessingImpl() override; bool RunImpl() override; @@ -21,8 +24,6 @@ class TestTaskMPI : public ppc::core::Task { int rc_size_{}; void MultiplyMatrixBasedOnRank(); - void MultiplyRowMajor(); - void MultiplyColumnMajor(); }; } // namespace nesterov_a_test_task_mpi diff --git a/tasks/mpi/example/src/ops_mpi.cpp b/tasks/mpi/example/src/ops_mpi.cpp index f668d8847..43821a5d5 100644 --- a/tasks/mpi/example/src/ops_mpi.cpp +++ b/tasks/mpi/example/src/ops_mpi.cpp @@ -28,28 +28,28 @@ void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyMatrixBasedOnRank() { MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { - MultiplyRowMajor(); + MultiplyRowMajor(input_, output_, rc_size_); } else { - MultiplyColumnMajor(); + MultiplyColumnMajor(input_, output_, rc_size_); } MPI_Barrier(MPI_COMM_WORLD); } -void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyRowMajor() { - for (int i = 0; i < rc_size_; ++i) { - for (int j = 0; j < rc_size_; ++j) { - for (int k = 0; k < rc_size_; ++k) { - output_[(i * rc_size_) + j] += input_[(i * rc_size_) + k] * input_[(k * rc_size_) + j]; +void nesterov_a_test_task_mpi::MultiplyRowMajor(const std::vector &in, std::vector &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) { + out[(i * rc_size) + j] += in[(i * rc_size) + k] * in[(k * rc_size) + j]; } } } } -void nesterov_a_test_task_mpi::TestTaskMPI::MultiplyColumnMajor() { - for (int j = 0; j < rc_size_; ++j) { - for (int k = 0; k < rc_size_; ++k) { - for (int i = 0; i < rc_size_; ++i) { - output_[(i * rc_size_) + j] += input_[(i * rc_size_) + k] * input_[(k * rc_size_) + j]; +void nesterov_a_test_task_mpi::MultiplyColumnMajor(const std::vector &in, std::vector &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) { + out[(i * rc_size) + j] += in[(i * rc_size) + k] * in[(k * rc_size) + j]; } } } From db89b5ac7735a81c2030a55d51a2aa8199328413 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Thu, 15 May 2025 18:30:34 +0200 Subject: [PATCH 18/22] reformat perf for increase coverage --- modules/core/perf/func_tests/perf_tests.cpp | 77 ++++++++------------- modules/core/perf/include/perf.hpp | 12 ++-- modules/core/perf/src/perf.cpp | 31 +++++---- tasks/all/example/perf_tests/main.cpp | 10 ++- tasks/mpi/example/perf_tests/main.cpp | 15 ++-- tasks/omp/example/perf_tests/main.cpp | 15 ++-- tasks/seq/example/perf_tests/main.cpp | 15 ++-- tasks/stl/example/perf_tests/main.cpp | 15 ++-- tasks/tbb/example/perf_tests/main.cpp | 15 ++-- 9 files changed, 85 insertions(+), 120 deletions(-) diff --git a/modules/core/perf/func_tests/perf_tests.cpp b/modules/core/perf/func_tests/perf_tests.cpp index bd24ba687..7704073c3 100644 --- a/modules/core/perf/func_tests/perf_tests.cpp +++ b/modules/core/perf/func_tests/perf_tests.cpp @@ -16,19 +16,16 @@ TEST(perf_tests, check_perf_pipeline) { // Create Task auto test_task = std::make_shared>(in); - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - - // Create and init perf results - ppc::core::PerfResults perf_results; - // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); - perf_analyzer.PipelineRun(perf_attr, perf_results); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + perf_analyzer.PipelineRun(perf_attr); // Get perf statistic - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); + perf_analyzer.PrintPerfStatistic(); + ASSERT_LE(perf_analyzer.GetPerfResults().time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } @@ -39,19 +36,16 @@ TEST(perf_tests, check_perf_pipeline_float) { // Create Task auto test_task = std::make_shared>(in); - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - - // Create and init perf results - ppc::core::PerfResults perf_results; - // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); - perf_analyzer.PipelineRun(perf_attr, perf_results); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + perf_analyzer.PipelineRun(perf_attr); // Get perf statistic - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); + perf_analyzer.PrintPerfStatistic(); + ASSERT_LE(perf_analyzer.GetPerfResults().time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } @@ -62,6 +56,9 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { // Create Task auto test_task = std::make_shared>(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task); + // Create Perf attributes ppc::core::PerfAttr perf_attr; perf_attr.num_running = 1; @@ -72,40 +69,28 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) { auto duration = std::chrono::duration_cast(current_time_point - t0).count(); return static_cast(duration) * 1e-9; }; - - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task); - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); // Get perf statistic - ASSERT_ANY_THROW(ppc::core::Perf::PrintPerfStatistic(perf_results)); + ASSERT_ANY_THROW(perf_analyzer.PrintPerfStatistic()); } -TEST(perf_tests, check_perf_task) { +TEST(perf_tests, check_perf_task_exception) { // Create data std::vector in(2000, 1); // Create Task auto test_task = std::make_shared>(in); - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - - // Create and init perf results - ppc::core::PerfResults perf_results; - // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); - perf_analyzer.TaskRun(perf_attr, perf_results); // Get perf statistic - perf_results.type_of_running = ppc::core::PerfResults::kNone; - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(test_task->Get(), in.size()); + ASSERT_ANY_THROW(perf_analyzer.PrintPerfStatistic()); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + perf_analyzer.TaskRun(perf_attr); } TEST(perf_tests, check_perf_task_float) { @@ -115,19 +100,15 @@ TEST(perf_tests, check_perf_task_float) { // Create Task auto test_task = std::make_shared>(in); - // Create Perf attributes - ppc::core::PerfAttr perf_attr; - - // Create and init perf results - ppc::core::PerfResults perf_results; - // Create Perf analyzer ppc::core::Perf perf_analyzer(test_task); - perf_analyzer.TaskRun(perf_attr, perf_results); + + // Create Perf attributes + ppc::core::PerfAttr perf_attr; + perf_analyzer.TaskRun(perf_attr); // Get perf statistic - perf_results.type_of_running = ppc::core::PerfResults::kPipeline; - ppc::core::Perf::PrintPerfStatistic(perf_results); - ASSERT_LE(perf_results.time_sec, ppc::core::PerfResults::kMaxTime); + perf_analyzer.PrintPerfStatistic(); + ASSERT_LE(perf_analyzer.GetPerfResults().time_sec, ppc::core::PerfResults::kMaxTime); EXPECT_EQ(test_task->Get(), in.size()); } diff --git a/modules/core/perf/include/perf.hpp b/modules/core/perf/include/perf.hpp index 2fe5c2fea..61cc68559 100644 --- a/modules/core/perf/include/perf.hpp +++ b/modules/core/perf/include/perf.hpp @@ -25,18 +25,18 @@ class Perf { public: // Init performance analysis with initialized task and initialized data explicit Perf(const std::shared_ptr& task_ptr); - // Set task with an initialized task and initialized data for performance - // analysis c - void SetTask(const std::shared_ptr& task_ptr); // Check performance of full task's pipeline: PreProcessing() -> // Validation() -> Run() -> PostProcessing() - void PipelineRun(const PerfAttr& perf_attr, PerfResults& perf_results) const; + void PipelineRun(const PerfAttr& perf_attr); // Check performance of task's Run() function - void TaskRun(const PerfAttr& perf_attr, PerfResults& perf_results) const; + void TaskRun(const PerfAttr& perf_attr); // Pint results for automation checkers - static void PrintPerfStatistic(const PerfResults& perf_results); + void PrintPerfStatistic() const; + // Get performance result structure of the current task + PerfResults GetPerfResults(); private: + PerfResults perf_results_; std::shared_ptr task_; static void CommonRun(const PerfAttr& perf_attr, const std::function& pipeline, PerfResults& perf_results); }; diff --git a/modules/core/perf/src/perf.cpp b/modules/core/perf/src/perf.cpp index f66cbbd49..aac88841c 100644 --- a/modules/core/perf/src/perf.cpp +++ b/modules/core/perf/src/perf.cpp @@ -13,15 +13,12 @@ #include "core/task/include/task.hpp" -ppc::core::Perf::Perf(const std::shared_ptr& task_ptr) { SetTask(task_ptr); } - -void ppc::core::Perf::SetTask(const std::shared_ptr& task_ptr) { +ppc::core::Perf::Perf(const std::shared_ptr& task_ptr) : task_(task_ptr) { task_ptr->GetStateOfTesting() = Task::StateOfTesting::kPerf; - this->task_ = task_ptr; } -void ppc::core::Perf::PipelineRun(const PerfAttr& perf_attr, ppc::core::PerfResults& perf_results) const { - perf_results.type_of_running = PerfResults::TypeOfRunning::kPipeline; +void ppc::core::Perf::PipelineRun(const PerfAttr& perf_attr) { + perf_results_.type_of_running = PerfResults::TypeOfRunning::kPipeline; CommonRun( perf_attr, @@ -31,15 +28,15 @@ void ppc::core::Perf::PipelineRun(const PerfAttr& perf_attr, ppc::core::PerfResu task_->Run(); task_->PostProcessing(); }, - perf_results); + perf_results_); } -void ppc::core::Perf::TaskRun(const PerfAttr& perf_attr, ppc::core::PerfResults& perf_results) const { - perf_results.type_of_running = PerfResults::TypeOfRunning::kTaskRun; +void ppc::core::Perf::TaskRun(const PerfAttr& perf_attr) { + perf_results_.type_of_running = PerfResults::TypeOfRunning::kTaskRun; task_->Validation(); task_->PreProcessing(); - CommonRun(perf_attr, [&]() { task_->Run(); }, perf_results); + CommonRun(perf_attr, [&]() { task_->Run(); }, perf_results_); task_->PostProcessing(); task_->Validation(); @@ -58,20 +55,22 @@ void ppc::core::Perf::CommonRun(const PerfAttr& perf_attr, const std::functioncurrent_test_info()->file()); std::string ppc_regex_template("parallel_programming_course"); std::string perf_regex_template("perf_tests"); std::string type_test_name; - auto time_secs = perf_results.time_sec; + auto time_secs = perf_results_.time_sec; - if (perf_results.type_of_running == PerfResults::TypeOfRunning::kTaskRun) { + if (perf_results_.type_of_running == PerfResults::TypeOfRunning::kTaskRun) { type_test_name = "task_run"; - } else if (perf_results.type_of_running == PerfResults::TypeOfRunning::kPipeline) { + } else if (perf_results_.type_of_running == PerfResults::TypeOfRunning::kPipeline) { type_test_name = "pipeline"; } else { - type_test_name = "none"; + std::stringstream err_msg; + err_msg << '\n' << "The type of performance check for the task was not selected.\n"; + throw std::runtime_error(err_msg.str().c_str()); } auto first_found_position = relative_path.find(ppc_regex_template) + ppc_regex_template.length() + 1; @@ -94,3 +93,5 @@ void ppc::core::Perf::PrintPerfStatistic(const PerfResults& perf_results) { throw std::runtime_error(err_msg.str().c_str()); } } + +ppc::core::PerfResults ppc::core::Perf::GetPerfResults() { return perf_results_; } diff --git a/tasks/all/example/perf_tests/main.cpp b/tasks/all/example/perf_tests/main.cpp index 3a33111ab..8c84f284e 100644 --- a/tasks/all/example/perf_tests/main.cpp +++ b/tasks/all/example/perf_tests/main.cpp @@ -23,6 +23,7 @@ class NesterovAllRunTest : public ::testing::TestWithParam(input_data); + ppc::core::Perf perf(task); ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -32,19 +33,16 @@ class NesterovAllRunTest : public ::testing::TestWithParam(ns) * 1e-9; }; - ppc::core::PerfResults perf_results; - ppc::core::Perf perf(task); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf.PipelineRun(perf_attr, perf_results); + perf.PipelineRun(perf_attr); } else { - perf.TaskRun(perf_attr, perf_results); + perf.TaskRun(perf_attr); } int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf.PrintPerfStatistic(); } ASSERT_EQ(input_data, task->Get()); diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index 1cf8827a0..336b661bf 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -25,6 +25,9 @@ class NesterovATaskMPITest : public ::testing::TestWithParam(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_mpi); + // Create Perf attributes ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -34,22 +37,16 @@ class NesterovATaskMPITest : public ::testing::TestWithParam(duration) * 1e-9; }; - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_mpi); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); } else { - perf_analyzer.TaskRun(perf_attr, perf_results); + perf_analyzer.TaskRun(perf_attr); } int rank = -1; MPI_Comm_rank(MPI_COMM_WORLD, &rank); if (rank == 0) { - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf_analyzer.PrintPerfStatistic(); } ASSERT_EQ(in, test_task_mpi->Get()); diff --git a/tasks/omp/example/perf_tests/main.cpp b/tasks/omp/example/perf_tests/main.cpp index 8c9594e23..6097e0c35 100644 --- a/tasks/omp/example/perf_tests/main.cpp +++ b/tasks/omp/example/perf_tests/main.cpp @@ -24,6 +24,9 @@ class NesterovTaskOMPTest : public ::testing::TestWithParam(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_omp); + // Create Perf attributes ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -33,19 +36,13 @@ class NesterovTaskOMPTest : public ::testing::TestWithParam(duration) * 1e-9; }; - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_omp); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); } else { - perf_analyzer.TaskRun(perf_attr, perf_results); + perf_analyzer.TaskRun(perf_attr); } - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf_analyzer.PrintPerfStatistic(); ASSERT_EQ(in, test_task_omp->Get()); } diff --git a/tasks/seq/example/perf_tests/main.cpp b/tasks/seq/example/perf_tests/main.cpp index 9e274f310..58462f01a 100644 --- a/tasks/seq/example/perf_tests/main.cpp +++ b/tasks/seq/example/perf_tests/main.cpp @@ -24,6 +24,9 @@ class NesterovTaskSeqTest : public ::testing::TestWithParam(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_sequential); + // Create Perf attributes ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -33,19 +36,13 @@ class NesterovTaskSeqTest : public ::testing::TestWithParam(duration) * 1e-9; }; - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_sequential); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); } else { - perf_analyzer.TaskRun(perf_attr, perf_results); + perf_analyzer.TaskRun(perf_attr); } - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf_analyzer.PrintPerfStatistic(); ASSERT_EQ(in, test_task_sequential->Get()); } diff --git a/tasks/stl/example/perf_tests/main.cpp b/tasks/stl/example/perf_tests/main.cpp index ace9e903a..fd8197c08 100644 --- a/tasks/stl/example/perf_tests/main.cpp +++ b/tasks/stl/example/perf_tests/main.cpp @@ -24,6 +24,9 @@ class NesterovTaskSTLTest : public ::testing::TestWithParam(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_stl); + // Create Perf attributes ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -33,19 +36,13 @@ class NesterovTaskSTLTest : public ::testing::TestWithParam(duration) * 1e-9; }; - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_stl); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); } else { - perf_analyzer.TaskRun(perf_attr, perf_results); + perf_analyzer.TaskRun(perf_attr); } - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf_analyzer.PrintPerfStatistic(); ASSERT_EQ(in, test_task_stl->Get()); } diff --git a/tasks/tbb/example/perf_tests/main.cpp b/tasks/tbb/example/perf_tests/main.cpp index c9302d055..cf80fe29d 100644 --- a/tasks/tbb/example/perf_tests/main.cpp +++ b/tasks/tbb/example/perf_tests/main.cpp @@ -24,6 +24,9 @@ class NesterovTaskTBBTest : public ::testing::TestWithParam(in); + // Create Perf analyzer + ppc::core::Perf perf_analyzer(test_task_tbb); + // Create Perf attributes ppc::core::PerfAttr perf_attr; const auto t0 = std::chrono::high_resolution_clock::now(); @@ -33,19 +36,13 @@ class NesterovTaskTBBTest : public ::testing::TestWithParam(duration) * 1e-9; }; - // Create and init perf results - ppc::core::PerfResults perf_results; - - // Create Perf analyzer - ppc::core::Perf perf_analyzer(test_task_tbb); - if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { - perf_analyzer.PipelineRun(perf_attr, perf_results); + perf_analyzer.PipelineRun(perf_attr); } else { - perf_analyzer.TaskRun(perf_attr, perf_results); + perf_analyzer.TaskRun(perf_attr); } - ppc::core::Perf::PrintPerfStatistic(perf_results); + perf_analyzer.PrintPerfStatistic(); ASSERT_EQ(in, test_task_tbb->Get()); } From bf36cb3efb69b06e9e01e006647c3ded88f66833 Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Thu, 15 May 2025 20:42:32 +0200 Subject: [PATCH 19/22] fix coverage yet --- tasks/all/example/src/ops_all.cpp | 13 +++---------- tasks/tbb/example/src/ops_tbb.cpp | 13 +++---------- 2 files changed, 6 insertions(+), 20 deletions(-) diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index 1e58f2ee4..eecb816e2 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -9,8 +9,7 @@ #include #include "core/util/include/util.hpp" -#include "oneapi/tbb/task_arena.h" -#include "oneapi/tbb/task_group.h" +#include "oneapi/tbb/parallel_for.h" void nesterov_a_test_task_all::MatMul(const std::vector &in_vec, int rc_size, std::vector &out_vec) { for (int i = 0; i < rc_size; ++i) { @@ -24,14 +23,8 @@ void nesterov_a_test_task_all::MatMul(const std::vector &in_vec, int rc_siz } void nesterov_a_test_task_all::MatMulTBB(const std::vector &in_vec, int rc_size, std::vector &out_vec) { - oneapi::tbb::task_arena arena(1); - arena.execute([&] { - tbb::task_group tg; - for (int i = 0; i < ppc::util::GetPPCNumThreads(); ++i) { - tg.run([&] { MatMul(in_vec, rc_size, out_vec); }); - } - tg.wait(); - }); + tbb::parallel_for(0, ppc::util::GetPPCNumThreads(), [&](int i) { MatMul(in_vec, rc_size - i, out_vec); }); + MatMul(in_vec, rc_size, out_vec); } bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { diff --git a/tasks/tbb/example/src/ops_tbb.cpp b/tasks/tbb/example/src/ops_tbb.cpp index 3f233a701..191dce5da 100644 --- a/tasks/tbb/example/src/ops_tbb.cpp +++ b/tasks/tbb/example/src/ops_tbb.cpp @@ -7,8 +7,7 @@ #include #include -#include "oneapi/tbb/task_arena.h" -#include "oneapi/tbb/task_group.h" +#include "oneapi/tbb/parallel_for.h" namespace { void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_vec) { @@ -35,14 +34,8 @@ bool nesterov_a_test_task_tbb::TestTaskTBB::PreProcessingImpl() { } bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { - oneapi::tbb::task_arena arena(1); - arena.execute([&] { - tbb::task_group tg; - for (int thr = 0; thr < ppc::util::GetPPCNumThreads(); ++thr) { - tg.run([&] { MatMul(input_, rc_size_, output_); }); - } - tg.wait(); - }); + tbb::parallel_for(0, ppc::util::GetPPCNumThreads(), [&](int i) { MatMul(input_, rc_size_ - i, output_); }); + MatMul(input_, rc_size_, output_); return true; } From c7e1d3bf2544d11267c34eceb7a9e08a60da04ae Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Fri, 16 May 2025 02:02:02 +0200 Subject: [PATCH 20/22] fix coverage yet 2 --- modules/core/task/func_tests/task_tests.cpp | 37 ++++++--- modules/core/task/include/task.hpp | 7 +- modules/core/task/src/task.cpp | 84 +++++++++++---------- modules/core/util/include/util.hpp | 3 + 4 files changed, 79 insertions(+), 52 deletions(-) diff --git a/modules/core/task/func_tests/task_tests.cpp b/modules/core/task/func_tests/task_tests.cpp index 7d1583888..36aae351c 100644 --- a/modules/core/task/func_tests/task_tests.cpp +++ b/modules/core/task/func_tests/task_tests.cpp @@ -6,6 +6,7 @@ #include #include "core/task/func_tests/test_task.hpp" +#include "core/util/include/util.hpp" TEST(task_tests, check_int32_t) { // Create data @@ -50,6 +51,10 @@ TEST(task_tests, check_validate_func) { // Check Result ASSERT_EQ(is_valid, false); + + test_task.PreProcessing(); + test_task.Run(); + test_task.PostProcessing(); } TEST(task_tests, check_double) { @@ -124,18 +129,30 @@ TEST(task_tests, check_float) { EXPECT_NEAR(test_task.Get(), in.size(), 1e-3); } -TEST(task_tests, check_wrong_order) { - // Create data - std::vector in(20, 1); +DEATH_TEST(task_tests, check_wrong_order) { + auto destroy_function = [] { + // Create data + std::vector in(20, 1); + + // Create Task + ppc::test::task::TestTask test_task(in); + bool is_valid = test_task.Validation(); + ASSERT_EQ(is_valid, true); + test_task.PreProcessing(); + test_task.PostProcessing(); + }; + EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*"); +} - // Create Task - ppc::test::task::TestTask test_task(in); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); +DEATH_TEST(task_tests, check_empty_order) { + auto destroy_function = [] { + // Create data + std::vector in(20, 1); - // Run Task - test_task.PreProcessing(); - ASSERT_ANY_THROW(test_task.PostProcessing()); + // Create Task + ppc::test::task::TestTask test_task(in); + }; + EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*"); } int main(int argc, char **argv) { diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp index 9910a1ac3..2a3813111 100644 --- a/modules/core/task/include/task.hpp +++ b/modules/core/task/include/task.hpp @@ -34,7 +34,8 @@ class Task { virtual ~Task(); protected: - virtual void InternalOrderTest(const std::string &str = __builtin_FUNCTION()) final; + virtual void InternalOrderTest(const std::string &str) final; + virtual void InternalTimeTest(const std::string &str) final; // implementation of "Validation" function virtual bool ValidationImpl() = 0; @@ -54,7 +55,9 @@ class Task { std::vector right_functions_order_ = {"Validation", "PreProcessing", "Run", "PostProcessing"}; static constexpr double kMaxTestTime = 1.0; std::chrono::high_resolution_clock::time_point tmp_time_point_; - bool functions_order_validation_ = true; + bool was_worked_ = false; + + bool IsFullPipelineStage(); }; } // namespace ppc::core diff --git a/modules/core/task/src/task.cpp b/modules/core/task/src/task.cpp index aaa98cb7c..97b335955 100644 --- a/modules/core/task/src/task.cpp +++ b/modules/core/task/src/task.cpp @@ -1,8 +1,10 @@ #include "core/task/include/task.hpp" +#include #include #include #include +#include #include #include #include @@ -10,81 +12,83 @@ #include #include +using namespace std::chrono; + ppc::core::Task::Task(StateOfTesting state_of_testing) : state_of_testing_(state_of_testing) { functions_order_.clear(); } bool ppc::core::Task::Validation() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); return ValidationImpl(); } bool ppc::core::Task::PreProcessing() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); + if (state_of_testing_ == StateOfTesting::kFunc) { + InternalTimeTest(__builtin_FUNCTION()); + } return PreProcessingImpl(); } bool ppc::core::Task::Run() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); return RunImpl(); } bool ppc::core::Task::PostProcessing() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); + if (state_of_testing_ == StateOfTesting::kFunc) { + InternalTimeTest(__builtin_FUNCTION()); + } return PostProcessingImpl(); } -void ppc::core::Task::InternalOrderTest(const std::string& str) { - if (!functions_order_.empty() && str == functions_order_.back() && str == "Run") { - return; - } - +void ppc::core::Task::InternalOrderTest(const std::string &str) { + was_worked_ = true; functions_order_.push_back(str); - - for (size_t i = 0; i < functions_order_.size(); i++) { - if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) { - functions_order_validation_ = false; - throw std::invalid_argument("ORDER OF FUNCTIONS IS NOT RIGHT: \n" + std::string("Serial number: ") + - std::to_string(i + 1) + "\n" + std::string("Your function: ") + functions_order_[i] + - "\n" + std::string("Expected function: ") + right_functions_order_[i]); - } + if (str == "PostProcessing" && IsFullPipelineStage()) { + functions_order_.clear(); } - - if (str == "PreProcessing" && state_of_testing_ == StateOfTesting::kFunc) { +} +void ppc::core::Task::InternalTimeTest(const std::string &str) { + if (str == "PreProcessing") { tmp_time_point_ = std::chrono::high_resolution_clock::now(); } - if (str == "PostProcessing" && state_of_testing_ == StateOfTesting::kFunc) { - auto end = std::chrono::high_resolution_clock::now(); - auto duration = std::chrono::duration_cast(end - tmp_time_point_).count(); - auto current_time = static_cast(duration) * 1e-9; + if (str == "PostProcessing") { + auto duration = duration_cast(high_resolution_clock::now() - tmp_time_point_).count(); + auto diff = static_cast(duration) * 1e-9; + std::stringstream err_msg; - if (current_time < kMaxTestTime) { - err_msg << "Test time:" << std::fixed << std::setprecision(10) << current_time; + if (diff < kMaxTestTime) { + err_msg << "Test time:" << std::fixed << std::setprecision(10) << diff; } else { err_msg << "\nTask execute time need to be: "; err_msg << "time < " << kMaxTestTime << " secs.\n"; - err_msg << "Original time in secs: " << current_time << '\n'; + err_msg << "Original time in secs: " << diff << '\n'; throw std::runtime_error(err_msg.str().c_str()); } } } +bool ppc::core::Task::IsFullPipelineStage() { + auto it = std::adjacent_find(functions_order_.begin() + 2, + functions_order_.begin() + static_cast(functions_order_.size() - 2), + std::not_equal_to<>()); + + return (functions_order_.size() >= 4 && functions_order_[0] == "Validation" && + functions_order_[1] == "PreProcessing" && functions_order_[2] == "Run" && + it == (functions_order_.begin() + static_cast(functions_order_.size() - 2)) && + functions_order_[functions_order_.size() - 1] == "PostProcessing"); +} + ppc::core::Task::~Task() { - if (functions_order_.empty()) { - std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: No task functions were executed\n"; + if (!functions_order_.empty() || !was_worked_) { + std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT! \n" + "Expected - \"Validation\", \"PreProcessing\", \"Run\", \"PostProcessing\" \n"; std::terminate(); + } else { + functions_order_.clear(); } - if (functions_order_validation_) { - for (size_t i = 0; i < functions_order_.size(); i++) { - if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) { - std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: \n" - << std::string("Serial number: ") << std::to_string(i + 1) << "\n" - << std::string("Your function: ") << functions_order_[i] << "\n" - << std::string("Expected function: ") << right_functions_order_[i] << "\n"; - std::terminate(); - } - } - } - functions_order_.clear(); } diff --git a/modules/core/util/include/util.hpp b/modules/core/util/include/util.hpp index c1d74e4e1..1ab924e16 100644 --- a/modules/core/util/include/util.hpp +++ b/modules/core/util/include/util.hpp @@ -5,6 +5,9 @@ #define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \ INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) // NOLINT +// NOLINTNEXTLINE +#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name) // NOLINT + namespace ppc::util { std::string GetAbsolutePath(const std::string &relative_path); From 677e6ea3799554b19494a6b9c58673d51b796e5c Mon Sep 17 00:00:00 2001 From: Alexander Nesterov Date: Fri, 16 May 2025 02:02:02 +0200 Subject: [PATCH 21/22] fix coverage 3 --- modules/core/task/func_tests/task_tests.cpp | 37 ++++++--- modules/core/task/include/task.hpp | 8 +- modules/core/task/src/task.cpp | 89 ++++++++++++--------- modules/core/util/include/util.hpp | 3 + 4 files changed, 86 insertions(+), 51 deletions(-) diff --git a/modules/core/task/func_tests/task_tests.cpp b/modules/core/task/func_tests/task_tests.cpp index 7d1583888..36aae351c 100644 --- a/modules/core/task/func_tests/task_tests.cpp +++ b/modules/core/task/func_tests/task_tests.cpp @@ -6,6 +6,7 @@ #include #include "core/task/func_tests/test_task.hpp" +#include "core/util/include/util.hpp" TEST(task_tests, check_int32_t) { // Create data @@ -50,6 +51,10 @@ TEST(task_tests, check_validate_func) { // Check Result ASSERT_EQ(is_valid, false); + + test_task.PreProcessing(); + test_task.Run(); + test_task.PostProcessing(); } TEST(task_tests, check_double) { @@ -124,18 +129,30 @@ TEST(task_tests, check_float) { EXPECT_NEAR(test_task.Get(), in.size(), 1e-3); } -TEST(task_tests, check_wrong_order) { - // Create data - std::vector in(20, 1); +DEATH_TEST(task_tests, check_wrong_order) { + auto destroy_function = [] { + // Create data + std::vector in(20, 1); + + // Create Task + ppc::test::task::TestTask test_task(in); + bool is_valid = test_task.Validation(); + ASSERT_EQ(is_valid, true); + test_task.PreProcessing(); + test_task.PostProcessing(); + }; + EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*"); +} - // Create Task - ppc::test::task::TestTask test_task(in); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); +DEATH_TEST(task_tests, check_empty_order) { + auto destroy_function = [] { + // Create data + std::vector in(20, 1); - // Run Task - test_task.PreProcessing(); - ASSERT_ANY_THROW(test_task.PostProcessing()); + // Create Task + ppc::test::task::TestTask test_task(in); + }; + EXPECT_DEATH_IF_SUPPORTED(destroy_function(), ".*ORDER OF FUNCTIONS IS NOT RIGHT.*"); } int main(int argc, char **argv) { diff --git a/modules/core/task/include/task.hpp b/modules/core/task/include/task.hpp index 9910a1ac3..630912060 100644 --- a/modules/core/task/include/task.hpp +++ b/modules/core/task/include/task.hpp @@ -34,7 +34,9 @@ class Task { virtual ~Task(); protected: - virtual void InternalOrderTest(const std::string &str = __builtin_FUNCTION()) final; + virtual void InternalOrderTest(const std::string &str) final; + + virtual void InternalTimeTest(const std::string &str) final; // implementation of "Validation" function virtual bool ValidationImpl() = 0; @@ -54,7 +56,9 @@ class Task { std::vector right_functions_order_ = {"Validation", "PreProcessing", "Run", "PostProcessing"}; static constexpr double kMaxTestTime = 1.0; std::chrono::high_resolution_clock::time_point tmp_time_point_; - bool functions_order_validation_ = true; + bool was_worked_ = false; + + bool IsFullPipelineStage(); }; } // namespace ppc::core diff --git a/modules/core/task/src/task.cpp b/modules/core/task/src/task.cpp index aaa98cb7c..59379c378 100644 --- a/modules/core/task/src/task.cpp +++ b/modules/core/task/src/task.cpp @@ -1,8 +1,10 @@ #include "core/task/include/task.hpp" +#include #include #include #include +#include #include #include #include @@ -10,81 +12,90 @@ #include #include +using namespace std::chrono; + ppc::core::Task::Task(StateOfTesting state_of_testing) : state_of_testing_(state_of_testing) { functions_order_.clear(); } bool ppc::core::Task::Validation() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); return ValidationImpl(); } bool ppc::core::Task::PreProcessing() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); + if (state_of_testing_ == StateOfTesting::kFunc) { + InternalTimeTest(__builtin_FUNCTION()); + } return PreProcessingImpl(); } bool ppc::core::Task::Run() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); return RunImpl(); } bool ppc::core::Task::PostProcessing() { - InternalOrderTest(); + InternalOrderTest(__builtin_FUNCTION()); + if (state_of_testing_ == StateOfTesting::kFunc) { + InternalTimeTest(__builtin_FUNCTION()); + } return PostProcessingImpl(); } -void ppc::core::Task::InternalOrderTest(const std::string& str) { - if (!functions_order_.empty() && str == functions_order_.back() && str == "Run") { - return; - } - +void ppc::core::Task::InternalOrderTest(const std::string &str) { functions_order_.push_back(str); - - for (size_t i = 0; i < functions_order_.size(); i++) { - if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) { - functions_order_validation_ = false; - throw std::invalid_argument("ORDER OF FUNCTIONS IS NOT RIGHT: \n" + std::string("Serial number: ") + - std::to_string(i + 1) + "\n" + std::string("Your function: ") + functions_order_[i] + - "\n" + std::string("Expected function: ") + right_functions_order_[i]); - } + if (str == "PostProcessing" && IsFullPipelineStage()) { + functions_order_.clear(); + } else { + was_worked_ = true; } +} - if (str == "PreProcessing" && state_of_testing_ == StateOfTesting::kFunc) { +void ppc::core::Task::InternalTimeTest(const std::string &str) { + if (str == "PreProcessing") { tmp_time_point_ = std::chrono::high_resolution_clock::now(); } - if (str == "PostProcessing" && state_of_testing_ == StateOfTesting::kFunc) { - auto end = std::chrono::high_resolution_clock::now(); - auto duration = std::chrono::duration_cast(end - tmp_time_point_).count(); - auto current_time = static_cast(duration) * 1e-9; + if (str == "PostProcessing") { + auto duration = duration_cast(high_resolution_clock::now() - tmp_time_point_).count(); + auto diff = static_cast(duration) * 1e-9; + std::stringstream err_msg; - if (current_time < kMaxTestTime) { - err_msg << "Test time:" << std::fixed << std::setprecision(10) << current_time; + if (diff < kMaxTestTime) { + err_msg << "Test time:" << std::fixed << std::setprecision(10) << diff; } else { err_msg << "\nTask execute time need to be: "; err_msg << "time < " << kMaxTestTime << " secs.\n"; - err_msg << "Original time in secs: " << current_time << '\n'; + err_msg << "Original time in secs: " << diff << '\n'; throw std::runtime_error(err_msg.str().c_str()); } } } +bool ppc::core::Task::IsFullPipelineStage() { + auto it = std::adjacent_find(functions_order_.begin() + 2, + functions_order_.begin() + static_cast(functions_order_.size() - 2), + std::not_equal_to<>()); + + return (functions_order_.size() >= 4 && functions_order_[0] == "Validation" && + functions_order_[1] == "PreProcessing" && functions_order_[2] == "Run" && + it == (functions_order_.begin() + static_cast(functions_order_.size() - 2)) && + functions_order_[functions_order_.size() - 1] == "PostProcessing"); +} + ppc::core::Task::~Task() { - if (functions_order_.empty()) { - std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: No task functions were executed\n"; + auto custom_terminate = []() { + std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT! \n" + "Expected - \"Validation\", \"PreProcessing\", \"Run\", \"PostProcessing\" \n"; + std::exit(404); + }; + std::set_terminate(custom_terminate); + + if (!functions_order_.empty() || !was_worked_) { std::terminate(); + } else { + functions_order_.clear(); } - if (functions_order_validation_) { - for (size_t i = 0; i < functions_order_.size(); i++) { - if (functions_order_[i] != right_functions_order_[i % right_functions_order_.size()]) { - std::cerr << "ORDER OF FUNCTIONS IS NOT RIGHT: \n" - << std::string("Serial number: ") << std::to_string(i + 1) << "\n" - << std::string("Your function: ") << functions_order_[i] << "\n" - << std::string("Expected function: ") << right_functions_order_[i] << "\n"; - std::terminate(); - } - } - } - functions_order_.clear(); } diff --git a/modules/core/util/include/util.hpp b/modules/core/util/include/util.hpp index c1d74e4e1..1ab924e16 100644 --- a/modules/core/util/include/util.hpp +++ b/modules/core/util/include/util.hpp @@ -5,6 +5,9 @@ #define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \ INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) // NOLINT +// NOLINTNEXTLINE +#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name) // NOLINT + namespace ppc::util { std::string GetAbsolutePath(const std::string &relative_path); From 21950bc2fb25e03052c71b7eb227b4f469b6d747 Mon Sep 17 00:00:00 2001 From: Nesterov Alexander Date: Fri, 16 May 2025 14:43:32 +0200 Subject: [PATCH 22/22] Update util.hpp --- modules/core/util/include/util.hpp | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/modules/core/util/include/util.hpp b/modules/core/util/include/util.hpp index 1ab924e16..80070d14a 100644 --- a/modules/core/util/include/util.hpp +++ b/modules/core/util/include/util.hpp @@ -1,12 +1,14 @@ #pragma once #include -// NOLINTNEXTLINE +/* NOLINTBEGIN */ #define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \ - INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) // NOLINT + INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) +/* NOLINTEND */ -// NOLINTNEXTLINE -#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name) // NOLINT +/* NOLINTBEGIN */ +#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name) +/* NOLINTEND */ namespace ppc::util {