diff --git a/modules/core/perf/func_tests/perf_tests.cpp b/modules/core/perf/func_tests/perf_tests.cpp index fd93b60a5..7704073c3 100644 --- a/modules/core/perf/func_tests/perf_tests.cpp +++ b/modules/core/perf/func_tests/perf_tests.cpp @@ -12,166 +12,103 @@ 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); - - // 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(); + auto test_task = std::make_shared>(in); // 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); - EXPECT_EQ(out[0], in.size()); + perf_analyzer.PrintPerfStatistic(); + ASSERT_LE(perf_analyzer.GetPerfResults().time_sec, ppc::core::PerfResults::kMaxTime); + 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); - - // 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(); + auto test_task = std::make_shared>(in); // 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); - EXPECT_EQ(out[0], in.size()); + perf_analyzer.PrintPerfStatistic(); + ASSERT_LE(perf_analyzer.GetPerfResults().time_sec, ppc::core::PerfResults::kMaxTime); + 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 analyzer + ppc::core::Perf perf_analyzer(test_task); + // 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(); - - // 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_GE(perf_results->time_sec, ppc::core::PerfResults::kMaxTime); - EXPECT_EQ(out[0], in.size()); + 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); - 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); - - // 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(); + auto test_task = std::make_shared>(in); // 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(out[0], 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) { // 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); - - // 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(); + auto test_task = std::make_shared>(in); // 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); - EXPECT_EQ(out[0], in.size()); + 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/func_tests/test_task.hpp b/modules/core/perf/func_tests/test_task.hpp index 80325225e..3a9982765 100644 --- a/modules/core/perf/func_tests/test_task.hpp +++ b/modules/core/perf/func_tests/test_task.hpp @@ -12,35 +12,35 @@ 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) : 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; } + 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..61cc68559 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; }; }; @@ -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 - // 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); // 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); // Pint results for automation checkers - static void PrintPerfStatistic(const std::shared_ptr& 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 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 b0244605a..aac88841c 100644 --- a/modules/core/perf/src/perf.cpp +++ b/modules/core/perf/src/perf.cpp @@ -13,16 +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) { - task_ptr->GetData()->state_of_testing = TaskData::StateOfTesting::kPerf; - this->task_ = task_ptr; +ppc::core::Perf::Perf(const std::shared_ptr& task_ptr) : task_(task_ptr) { + task_ptr->GetStateOfTesting() = Task::StateOfTesting::kPerf; } -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) { + perf_results_.type_of_running = PerfResults::TypeOfRunning::kPipeline; CommonRun( perf_attr, @@ -32,16 +28,15 @@ void ppc::core::Perf::PipelineRun(const std::shared_ptr& perf_attr, task_->Run(); task_->PostProcessing(); }, - perf_results); + 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) { + 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(); @@ -50,30 +45,32 @@ 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 { 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"; + 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; @@ -96,3 +93,5 @@ void ppc::core::Perf::PrintPerfStatistic(const std::shared_ptr& per throw std::runtime_error(err_msg.str().c_str()); } } + +ppc::core::PerfResults ppc::core::Perf::GetPerfResults() { return perf_results_; } diff --git a/modules/core/task/func_tests/task_tests.cpp b/modules/core/task/func_tests/task_tests.cpp index d68d2ad1a..36aae351c 100644 --- a/modules/core/task/func_tests/task_tests.cpp +++ b/modules/core/task/func_tests/task_tests.cpp @@ -6,176 +6,153 @@ #include #include "core/task/func_tests/test_task.hpp" -#include "core/task/include/task.hpp" +#include "core/util/include/util.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.PreProcessing(); + test_task.Run(); + test_task.PostProcessing(); } 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); +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_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()); +DEATH_TEST(task_tests, check_empty_order) { + auto destroy_function = [] { + // Create data + std::vector in(20, 1); - // Create Task - ppc::test::task::TestTask test_task(task_data); - bool is_valid = test_task.Validation(); - ASSERT_EQ(is_valid, true); - 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/func_tests/test_task.hpp b/modules/core/task/func_tests/test_task.hpp index 5a31990db..ec79cefbf 100644 --- a/modules/core/task/func_tests/test_task.hpp +++ b/modules/core/task/func_tests/test_task.hpp @@ -11,34 +11,35 @@ 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) : 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; } + 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..630912060 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 = StateOfTesting::kFunc); // validation of data and validation of task attributes before running virtual bool Validation() final; @@ -33,39 +22,43 @@ 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; + virtual void InternalOrderTest(const std::string &str) final; - // implementation of "validation" function + virtual void InternalTimeTest(const std::string &str) final; + + // 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; 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 92b16d769..086b6a578 100644 --- a/modules/core/task/src/task.cpp +++ b/modules/core/task/src/task.cpp @@ -1,8 +1,11 @@ #include "core/task/include/task.hpp" +#include #include #include +#include #include +#include #include #include #include @@ -10,87 +13,89 @@ #include #include -void ppc::core::Task::SetData(TaskDataPtr task_data_ptr) { - task_data_ptr->state_of_testing = TaskData::StateOfTesting::kFunc; +using namespace std::chrono; + +ppc::core::Task::Task(StateOfTesting state_of_testing) : state_of_testing_(state_of_testing) { + 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); 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(); + 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" && task_data->state_of_testing == TaskData::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" && task_data->state_of_testing == TaskData::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::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 6a5db269f..80070d14a 100644 --- a/modules/core/util/include/util.hpp +++ b/modules/core/util/include/util.hpp @@ -1,6 +1,15 @@ #pragma once #include +/* NOLINTBEGIN */ +#define INSTANTIATE_TEST_SUITE_P_NOLINT(prefix, test_case_name, generator) \ + INSTANTIATE_TEST_SUITE_P(prefix, test_case_name, generator) +/* NOLINTEND */ + +/* NOLINTBEGIN */ +#define DEATH_TEST(test_suite_name, test_name) TEST(test_suite_name, test_name) +/* NOLINTEND */ + namespace ppc::util { std::string GetAbsolutePath(const std::string &relative_path); 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/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}.") 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": 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 4dc7fdf2e..000000000 --- a/tasks/all/example/func_tests/func_all.cpp +++ /dev/null @@ -1,76 +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); - 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); - ASSERT_EQ(test_task_all.Validation(), true); - test_task_all.PreProcessing(); - test_task_all.Run(); - test_task_all.PostProcessing(); - EXPECT_EQ(in, out); -} - -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); - 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); - ASSERT_EQ(test_task_all.Validation(), true); - test_task_all.PreProcessing(); - test_task_all.Run(); - test_task_all.PostProcessing(); - EXPECT_EQ(in, out); -} diff --git a/tasks/all/example/func_tests/main.cpp b/tasks/all/example/func_tests/main.cpp new file mode 100644 index 000000000..b506003ab --- /dev/null +++ b/tasks/all/example/func_tests/main.cpp @@ -0,0 +1,74 @@ +#include + +#include +#include +#include +#include + +#include "all/example/include/ops_all.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()); +} + +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 101339dec..fab463ee8 100644 --- a/tasks/all/example/include/ops_all.hpp +++ b/tasks/all/example/include/ops_all.hpp @@ -7,13 +7,17 @@ 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(ppc::core::TaskDataPtr task_data) : Task(std::move(task_data)) {} - bool PreProcessingImpl() override; + explicit TestTaskALL(const std::vector &in) : input_(in) {} bool ValidationImpl() override; + bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + std::vector Get(); private: std::vector input_, output_; diff --git a/tasks/all/example/perf_tests/main.cpp b/tasks/all/example/perf_tests/main.cpp new file mode 100644 index 000000000..8c84f284e --- /dev/null +++ b/tasks/all/example/perf_tests/main.cpp @@ -0,0 +1,56 @@ +#include +#include + +#include +#include +#include + +#include "all/example/include/ops_all.hpp" +#include "core/perf/include/perf.hpp" +#include "core/util/include/util.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::Perf perf(task); + + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf.PipelineRun(perf_attr); + } else { + perf.TaskRun(perf_attr); + } + + int rank = -1; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + if (rank == 0) { + perf.PrintPerfStatistic(); + } + + ASSERT_EQ(input_data, task->Get()); + } +}; + +TEST_P(NesterovAllRunTest, RunModes) { ExecuteTest(GetParam()); } + +INSTANTIATE_TEST_SUITE_P_NOLINT(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 5393ff606..000000000 --- a/tasks/all/example/perf_tests/perf_all.cpp +++ /dev/null @@ -1,105 +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); - 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); - - // 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(); - 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(); - - auto perf_analyzer = std::make_shared(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, out); -} - -TEST(nesterov_a_test_task_all, test_task_run) { - constexpr int kCount = 400; - - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - auto perf_analyzer = std::make_shared(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, out); -} diff --git a/tasks/all/example/src/ops_all.cpp b/tasks/all/example/src/ops_all.cpp index 84cec9a3e..eecb816e2 100644 --- a/tasks/all/example/src/ops_all.cpp +++ b/tasks/all/example/src/ops_all.cpp @@ -9,11 +9,9 @@ #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" -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,24 +21,22 @@ void MatMul(const std::vector &in_vec, int rc_size, std::vector &out_v } } } -} // namespace -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)); - return true; +void nesterov_a_test_task_all::MatMulTBB(const std::vector &in_vec, int rc_size, std::vector &out_vec) { + tbb::parallel_for(0, ppc::util::GetPPCNumThreads(), [&](int i) { MatMul(in_vec, rc_size - i, out_vec); }); + MatMul(in_vec, rc_size, out_vec); } bool nesterov_a_test_task_all::TestTaskALL::ValidationImpl() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; + 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(input_.size(), 0); + return true; } bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { @@ -50,17 +46,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(); @@ -74,9 +63,6 @@ bool nesterov_a_test_task_all::TestTaskALL::RunImpl() { return true; } -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; -} +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/func_tests/main.cpp b/tasks/mpi/example/func_tests/main.cpp index 77f89c737..493083f03 100644 --- a/tasks/mpi/example/func_tests/main.cpp +++ b/tasks/mpi/example/func_tests/main.cpp @@ -7,69 +7,68 @@ #include #include -#include "core/task/include/task.hpp" #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; +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 data - std::vector in(kCount * kCount, 0); - std::vector out(kCount * kCount, 0); + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } - for (size_t i = 0; i < kCount; i++) { - in[(i * kCount) + i] = 1; - } + int base_count = 0; +}; + +TEST_P(NesterovATestTaskMPI, MatmulFromFile) { + const size_t count = GetCount(); - // 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()); + 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(task_data_mpi); - ASSERT_EQ(test_task_mpi.Validation(), true); + nesterov_a_test_task_mpi::TestTaskMPI test_task_mpi(in); + ASSERT_TRUE(test_task_mpi.Validation()); 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) { - std::string line; - std::ifstream test_file(ppc::util::GetAbsolutePath("mpi/example/data/test.txt")); - if (test_file.is_open()) { - getline(test_file, line); - } - test_file.close(); - - const size_t count = std::stoi(line); +TEST_P(NesterovATestTaskMPI, MultiplyRowMajorUtilTestFromFile) { + const size_t count = GetCount(); - // Create data 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)); - for (size_t i = 0; i < count; i++) { + 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; } - // 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); - ASSERT_EQ(test_task_mpi.Validation(), true); - test_task_mpi.PreProcessing(); - test_task_mpi.Run(); - test_task_mpi.PostProcessing(); + 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 700f1be02..31b1f0424 100644 --- a/tasks/mpi/example/include/ops_mpi.hpp +++ b/tasks/mpi/example/include/ops_mpi.hpp @@ -7,21 +7,23 @@ 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(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(); private: std::vector input_, output_; int rc_size_{}; void MultiplyMatrixBasedOnRank(); - void MultiplyRowMajor(); - void MultiplyColumnMajor(); }; } // namespace nesterov_a_test_task_mpi diff --git a/tasks/mpi/example/perf_tests/main.cpp b/tasks/mpi/example/perf_tests/main.cpp index 223909378..336b661bf 100644 --- a/tasks/mpi/example/perf_tests/main.cpp +++ b/tasks/mpi/example/perf_tests/main.cpp @@ -8,98 +8,53 @@ #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" -TEST(nesterov_a_test_task_mpi, test_pipeline_run) { - constexpr int kCount = 500; - - // 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); - - // 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(); - 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(); - - auto perf_analyzer = std::make_shared(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, out); -} - -TEST(nesterov_a_test_task_mpi, test_task_run) { - constexpr int kCount = 500; - - // 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; +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 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(); + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr); + } else { + perf_analyzer.TaskRun(perf_attr); + } + + int rank = -1; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + if (rank == 0) { + perf_analyzer.PrintPerfStatistic(); + } + + ASSERT_EQ(in, test_task_mpi->Get()); } +}; - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - auto perf_analyzer = std::make_shared(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, out); -} +INSTANTIATE_TEST_SUITE_P_NOLINT(NesterovATests, NesterovATaskMPITest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/mpi/example/src/ops_mpi.cpp b/tasks/mpi/example/src/ops_mpi.cpp index 331d278df..43821a5d5 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; @@ -34,36 +28,33 @@ 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]; } } } } -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; -} +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/func_tests/main.cpp b/tasks/omp/example/func_tests/main.cpp index 564a700f3..278b5d479 100644 --- a/tasks/omp/example/func_tests/main.cpp +++ b/tasks/omp/example/func_tests/main.cpp @@ -11,63 +11,37 @@ #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); - std::vector out(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_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); - ASSERT_EQ(test_task_omp.Validation(), true); - test_task_omp.PreProcessing(); - test_task_omp.Run(); - test_task_omp.PostProcessing(); - EXPECT_EQ(in, out); -} + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } -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); - } - test_file.close(); + int base_count = 0; +}; - const size_t count = std::stoi(line); +TEST_P(NesterovATestTaskOMP, MatmulFromFile) { + const size_t count = GetCount(); - // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); - - for (size_t i = 0; i < count; i++) { + 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); - ASSERT_EQ(test_task_omp.Validation(), true); + nesterov_a_test_task_omp::TestTaskOpenMP test_task_omp(in); + ASSERT_TRUE(test_task_omp.Validation()); test_task_omp.PreProcessing(); test_task_omp.Run(); test_task_omp.PostProcessing(); - EXPECT_EQ(in, out); + + EXPECT_EQ(in, test_task_omp.Get()); } + +INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTestsOMP, NesterovATestTaskOMP, ::testing::Values(0.5, 1.0)); diff --git a/tasks/omp/example/include/ops_omp.hpp b/tasks/omp/example/include/ops_omp.hpp index fef03e988..87209c39e 100644 --- a/tasks/omp/example/include/ops_omp.hpp +++ b/tasks/omp/example/include/ops_omp.hpp @@ -9,11 +9,12 @@ 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(); 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..6097e0c35 100644 --- a/tasks/omp/example/perf_tests/main.cpp +++ b/tasks/omp/example/perf_tests/main.cpp @@ -7,87 +7,49 @@ #include #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" -TEST(nesterov_a_test_task_omp, test_pipeline_run) { - constexpr int kCount = 300; - - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - 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); -} - -TEST(nesterov_a_test_task_omp, test_task_run) { - constexpr int kCount = 300; - - // 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; +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 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(); + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr); + } else { + perf_analyzer.TaskRun(perf_attr); + } + + perf_analyzer.PrintPerfStatistic(); + + ASSERT_EQ(in, test_task_omp->Get()); } +}; - // 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); - - // 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(); - 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(); +TEST_P(NesterovTaskOMPTest, RunModes) { RunTest(GetParam()); } - // Create Perf analyzer - 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); -} +INSTANTIATE_TEST_SUITE_P_NOLINT(NesterovOMPTests, NesterovTaskOMPTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/omp/example/src/ops_omp.cpp b/tasks/omp/example/src/ops_omp.cpp index 7db50f2d5..380be6aa8 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() { @@ -41,9 +34,6 @@ bool nesterov_a_test_task_omp::TestTaskOpenMP::RunImpl() { return true; } -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; -} +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/func_tests/main.cpp b/tasks/seq/example/func_tests/main.cpp index 54ddb2c42..cf196f774 100644 --- a/tasks/seq/example/func_tests/main.cpp +++ b/tasks/seq/example/func_tests/main.cpp @@ -11,63 +11,36 @@ #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); - std::vector out(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_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()); + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } - // Create Task - nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(task_data_seq); - ASSERT_EQ(test_task_sequential.Validation(), true); - test_task_sequential.PreProcessing(); - test_task_sequential.Run(); - test_task_sequential.PostProcessing(); - EXPECT_EQ(in, out); -} + int base_count = 0; +}; -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); - } - test_file.close(); - - const size_t count = std::stoi(line); +TEST_P(NesterovATestTaskSeq, MatmulFromFile) { + const size_t count = GetCount(); - // 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); - ASSERT_EQ(test_task_sequential.Validation(), true); + nesterov_a_test_task_seq::TestTaskSequential test_task_sequential(in); + ASSERT_TRUE(test_task_sequential.Validation()); test_task_sequential.PreProcessing(); test_task_sequential.Run(); test_task_sequential.PostProcessing(); - EXPECT_EQ(in, out); + EXPECT_EQ(in, test_task_sequential.Get()); } + +INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTests, NesterovATestTaskSeq, ::testing::Values(0.5, 1.0)); diff --git a/tasks/seq/example/include/ops_seq.hpp b/tasks/seq/example/include/ops_seq.hpp index 728bde58d..f03fc7fb8 100644 --- a/tasks/seq/example/include/ops_seq.hpp +++ b/tasks/seq/example/include/ops_seq.hpp @@ -9,11 +9,12 @@ 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(); 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..58462f01a 100644 --- a/tasks/seq/example/perf_tests/main.cpp +++ b/tasks/seq/example/perf_tests/main.cpp @@ -7,87 +7,49 @@ #include #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" -TEST(nesterov_a_test_task_seq, test_pipeline_run) { - constexpr int kCount = 500; - - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - 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); -} - -TEST(nesterov_a_test_task_seq, test_task_run) { - constexpr int kCount = 500; - - // 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; +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 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(); + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr); + } else { + perf_analyzer.TaskRun(perf_attr); + } + + perf_analyzer.PrintPerfStatistic(); + + ASSERT_EQ(in, test_task_sequential->Get()); } +}; - // 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); - - // 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(); - 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(); +TEST_P(NesterovTaskSeqTest, RunModes) { RunTest(GetParam()); } - // Create Perf analyzer - 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); -} +INSTANTIATE_TEST_SUITE_P_NOLINT(NesterovSeqTests, NesterovTaskSeqTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/seq/example/src/ops_seq.cpp b/tasks/seq/example/src/ops_seq.cpp index 23639db05..40df2e006 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() { @@ -34,9 +27,6 @@ bool nesterov_a_test_task_seq::TestTaskSequential::RunImpl() { return true; } -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; -} +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/func_tests/main.cpp b/tasks/stl/example/func_tests/main.cpp index 77ffa5a5c..0460c3a2c 100644 --- a/tasks/stl/example/func_tests/main.cpp +++ b/tasks/stl/example/func_tests/main.cpp @@ -11,63 +11,37 @@ #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); - std::vector out(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_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); - ASSERT_EQ(test_task_stl.Validation(), true); - test_task_stl.PreProcessing(); - test_task_stl.Run(); - test_task_stl.PostProcessing(); - EXPECT_EQ(in, out); -} + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } -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); - } - test_file.close(); + int base_count = 0; +}; - const size_t count = std::stoi(line); +TEST_P(NesterovATestTaskSTL, MatmulFromFile) { + const size_t count = GetCount(); - // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); - - for (size_t i = 0; i < count; i++) { + 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); - ASSERT_EQ(test_task_stl.Validation(), true); + nesterov_a_test_task_stl::TestTaskSTL test_task_stl(in); + ASSERT_TRUE(test_task_stl.Validation()); test_task_stl.PreProcessing(); test_task_stl.Run(); test_task_stl.PostProcessing(); - EXPECT_EQ(in, out); + + EXPECT_EQ(in, test_task_stl.Get()); } + +INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTestsSTL, NesterovATestTaskSTL, ::testing::Values(0.5, 1.0)); diff --git a/tasks/stl/example/include/ops_stl.hpp b/tasks/stl/example/include/ops_stl.hpp index 05b6b6dbf..1461d8ca2 100644 --- a/tasks/stl/example/include/ops_stl.hpp +++ b/tasks/stl/example/include/ops_stl.hpp @@ -9,11 +9,12 @@ 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(); 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..fd8197c08 100644 --- a/tasks/stl/example/perf_tests/main.cpp +++ b/tasks/stl/example/perf_tests/main.cpp @@ -7,87 +7,49 @@ #include #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" -TEST(nesterov_a_test_task_stl, test_pipeline_run) { - constexpr int kCount = 450; - - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - 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); -} - -TEST(nesterov_a_test_task_stl, test_task_run) { - constexpr int kCount = 450; - - // 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; +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 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(); + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr); + } else { + perf_analyzer.TaskRun(perf_attr); + } + + perf_analyzer.PrintPerfStatistic(); + + ASSERT_EQ(in, test_task_stl->Get()); } +}; - // 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); - - // 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(); - 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(); +TEST_P(NesterovTaskSTLTest, RunModes) { RunTest(GetParam()); } - // Create Perf analyzer - 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); -} +INSTANTIATE_TEST_SUITE_P_NOLINT(NesterovSTLTests, NesterovTaskSTLTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/stl/example/src/ops_stl.cpp b/tasks/stl/example/src/ops_stl.cpp index 199935889..608360d54 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() { @@ -49,9 +42,6 @@ bool nesterov_a_test_task_stl::TestTaskSTL::RunImpl() { return true; } -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; -} +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/func_tests/main.cpp b/tasks/tbb/example/func_tests/main.cpp index 3e1ac5a8a..c4236089b 100644 --- a/tasks/tbb/example/func_tests/main.cpp +++ b/tasks/tbb/example/func_tests/main.cpp @@ -11,63 +11,37 @@ #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); - std::vector out(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_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); - ASSERT_EQ(test_task_tbb.Validation(), true); - test_task_tbb.PreProcessing(); - test_task_tbb.Run(); - test_task_tbb.PostProcessing(); - EXPECT_EQ(in, out); -} + [[nodiscard]] size_t GetCount() const { return static_cast(base_count * GetParam()); } -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); - } - test_file.close(); + int base_count = 0; +}; - const size_t count = std::stoi(line); +TEST_P(NesterovATestTaskTBB, MatmulFromFile) { + const size_t count = GetCount(); - // Create data std::vector in(count * count, 0); - std::vector out(count * count, 0); - - for (size_t i = 0; i < count; i++) { + 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); - ASSERT_EQ(test_task_tbb.Validation(), true); + nesterov_a_test_task_tbb::TestTaskTBB test_task_tbb(in); + ASSERT_TRUE(test_task_tbb.Validation()); test_task_tbb.PreProcessing(); test_task_tbb.Run(); test_task_tbb.PostProcessing(); - EXPECT_EQ(in, out); + + EXPECT_EQ(in, test_task_tbb.Get()); } + +INSTANTIATE_TEST_SUITE_P_NOLINT(FileMatrixTestsTBB, NesterovATestTaskTBB, ::testing::Values(0.5, 1.0)); diff --git a/tasks/tbb/example/include/ops_tbb.hpp b/tasks/tbb/example/include/ops_tbb.hpp index 4e6286bd5..4df85defb 100644 --- a/tasks/tbb/example/include/ops_tbb.hpp +++ b/tasks/tbb/example/include/ops_tbb.hpp @@ -9,11 +9,12 @@ 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(); 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..cf80fe29d 100644 --- a/tasks/tbb/example/perf_tests/main.cpp +++ b/tasks/tbb/example/perf_tests/main.cpp @@ -7,87 +7,49 @@ #include #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" -TEST(nesterov_a_test_task_tbb, test_pipeline_run) { - constexpr int kCount = 450; - - // 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); - - // 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(); - 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(); - - // Create Perf analyzer - 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); -} - -TEST(nesterov_a_test_task_tbb, test_task_run) { - constexpr int kCount = 450; - - // 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; +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 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(); + 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; + }; + + if (mode == ppc::core::PerfResults::TypeOfRunning::kPipeline) { + perf_analyzer.PipelineRun(perf_attr); + } else { + perf_analyzer.TaskRun(perf_attr); + } + + perf_analyzer.PrintPerfStatistic(); + + ASSERT_EQ(in, test_task_tbb->Get()); } +}; - // 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); - - // 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(); - 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(); +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, out); -} +INSTANTIATE_TEST_SUITE_P_NOLINT(NesterovTBBTests, NesterovTaskTBBTest, + ::testing::Values(ppc::core::PerfResults::TypeOfRunning::kPipeline, + ppc::core::PerfResults::TypeOfRunning::kTaskRun)); diff --git a/tasks/tbb/example/src/ops_tbb.cpp b/tasks/tbb/example/src/ops_tbb.cpp index 730dfaf5b..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) { @@ -23,39 +22,23 @@ 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() { - // Check equality of counts elements - return task_data->inputs_count[0] == task_data->outputs_count[0]; + 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::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(); - }); +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::PostProcessingImpl() { - for (size_t i = 0; i < output_.size(); i++) { - reinterpret_cast(task_data->outputs[0])[i] = output_[i]; - } +bool nesterov_a_test_task_tbb::TestTaskTBB::RunImpl() { + tbb::parallel_for(0, ppc::util::GetPPCNumThreads(), [&](int i) { MatMul(input_, rc_size_ - i, output_); }); + MatMul(input_, rc_size_, output_); return true; } + +bool nesterov_a_test_task_tbb::TestTaskTBB::PostProcessingImpl() { return true; } + +std::vector nesterov_a_test_task_tbb::TestTaskTBB::Get() { return output_; }