From e9b9696526f9fb563c21d9ba1d2a8e76f092721f Mon Sep 17 00:00:00 2001 From: Arseniy Obolenskiy Date: Sat, 30 Dec 2023 00:48:33 +0800 Subject: [PATCH] Apply clang-format on repository --- 3rdparty/unapproved/unapproved.h | 4 +- first_samples/mpi/main.cpp | 29 +- first_samples/mpi_boost/main.cpp | 22 +- modules/core/include/perf.hpp | 41 +- modules/core/include/task.hpp | 53 +-- modules/core/src/perf.cpp | 58 +-- modules/core/src/task.cpp | 39 +- modules/core/tests/core_tests.cpp | 310 +++++++-------- modules/core/tests/test_task.hpp | 63 ++-- .../average_of_vector_elements/ref_task.hpp | 75 ++-- .../average_of_vector_elements/ref_tests.cpp | 228 +++++------ .../max_of_vector_elements/ref_task.hpp | 105 +++--- .../max_of_vector_elements/ref_tests.cpp | 319 ++++++++-------- .../min_of_vector_elements/ref_task.hpp | 105 +++--- .../min_of_vector_elements/ref_tests.cpp | 319 ++++++++-------- .../ref_task.hpp | 108 +++--- .../ref_tests.cpp | 353 ++++++++++-------- .../nearest_neighbor_elements/ref_task.hpp | 108 +++--- .../nearest_neighbor_elements/ref_tests.cpp | 347 +++++++++-------- .../num_of_alternations_signs/ref_task.hpp | 88 +++-- .../num_of_alternations_signs/ref_tests.cpp | 244 ++++++------ .../num_of_orderly_violations/ref_task.hpp | 90 ++--- .../num_of_orderly_violations/ref_tests.cpp | 244 ++++++------ .../sum_of_vector_elements/ref_task.hpp | 71 ++-- .../sum_of_vector_elements/ref_tests.cpp | 204 +++++----- .../sum_values_by_rows_matrix/ref_task.hpp | 87 +++-- .../sum_values_by_rows_matrix/ref_tests.cpp | 344 ++++++++--------- .../reference/vector_dot_product/ref_task.hpp | 82 ++-- .../vector_dot_product/ref_tests.cpp | 327 ++++++++-------- tasks/examples/test_mpi/main.cpp | 137 +++---- tasks/examples/test_mpi/ops_mpi.cpp | 105 +++--- tasks/examples/test_mpi/ops_mpi.h | 8 +- tasks/examples/test_omp/main.cpp | 46 +-- tasks/examples/test_omp/ops_omp.cpp | 96 ++--- tasks/examples/test_omp/ops_omp.h | 4 +- tasks/examples/test_seq/main.cpp | 61 +-- tasks/examples/test_std/main.cpp | 56 +-- tasks/examples/test_std/ops_std.cpp | 118 +++--- tasks/examples/test_std/ops_std.h | 4 +- tasks/examples/test_tbb/main.cpp | 46 +-- tasks/examples/test_tbb/ops_tbb.cpp | 122 +++--- tasks/examples/test_tbb/ops_tbb.h | 2 +- 42 files changed, 2758 insertions(+), 2514 deletions(-) diff --git a/3rdparty/unapproved/unapproved.h b/3rdparty/unapproved/unapproved.h index 40e394ad..333249c5 100644 --- a/3rdparty/unapproved/unapproved.h +++ b/3rdparty/unapproved/unapproved.h @@ -1,3 +1,3 @@ -#include -#include #include +#include +#include diff --git a/first_samples/mpi/main.cpp b/first_samples/mpi/main.cpp index 05bc06b4..5f81f7cb 100644 --- a/first_samples/mpi/main.cpp +++ b/first_samples/mpi/main.cpp @@ -1,25 +1,26 @@ // Copyright 2023 Nesterov Alexander #include + #include int main(int argc, char** argv) { - MPI_Init(&argc, &argv); + MPI_Init(&argc, &argv); - int world_size; - MPI_Comm_size(MPI_COMM_WORLD, &world_size); + int world_size; + MPI_Comm_size(MPI_COMM_WORLD, &world_size); - int world_rank; - MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); + int world_rank; + MPI_Comm_rank(MPI_COMM_WORLD, &world_rank); - char processor_name[MPI_MAX_PROCESSOR_NAME]; - int len_chars; - MPI_Get_processor_name(processor_name, &len_chars); + char processor_name[MPI_MAX_PROCESSOR_NAME]; + int len_chars; + MPI_Get_processor_name(processor_name, &len_chars); - MPI_Barrier(MPI_COMM_WORLD); - std::cout << "Processor = " << processor_name << std::endl; - std::cout << "Rank = " << world_rank << std::endl; - std::cout << "Number of processors = " << world_size << std::endl; + MPI_Barrier(MPI_COMM_WORLD); + std::cout << "Processor = " << processor_name << std::endl; + std::cout << "Rank = " << world_rank << std::endl; + std::cout << "Number of processors = " << world_size << std::endl; - MPI_Finalize(); - return 0; + MPI_Finalize(); + return 0; } \ No newline at end of file diff --git a/first_samples/mpi_boost/main.cpp b/first_samples/mpi_boost/main.cpp index 8fcd8206..f0123295 100644 --- a/first_samples/mpi_boost/main.cpp +++ b/first_samples/mpi_boost/main.cpp @@ -1,19 +1,21 @@ // Copyright 2023 Nesterov Alexander #include -#include -#include -#include + #include +#include +#include +#include // https://www.boost.org/doc/libs/1_68_0/doc/html/mpi/tutorial.html int main(int argc, char** argv) { - boost::mpi::environment env(argc, argv); - boost::mpi::communicator world; + boost::mpi::environment env(argc, argv); + boost::mpi::communicator world; - world.barrier(); - std::cout << "Processor = " << boost::mpi::environment::processor_name() << std::endl; - std::cout << "Rank = " << world.rank() << std::endl; - std::cout << "Number of processors = " << world.size() << std::endl; + world.barrier(); + std::cout << "Processor = " << boost::mpi::environment::processor_name() + << std::endl; + std::cout << "Rank = " << world.rank() << std::endl; + std::cout << "Number of processors = " << world.size() << std::endl; - return 0; + return 0; } \ No newline at end of file diff --git a/modules/core/include/perf.hpp b/modules/core/include/perf.hpp index 331d777c..085aec07 100644 --- a/modules/core/include/perf.hpp +++ b/modules/core/include/perf.hpp @@ -4,38 +4,45 @@ #define MODULES_CORE_INCLUDE_PERF_HPP_ #include -#include -#include #include +#include +#include + #include "core/include/task.hpp" namespace ppc { namespace core { struct PerfAttr { - // count of task's running - uint64_t num_running; + // count of task's running + uint64_t num_running; }; struct PerfResults { - // measurement of task's time (in seconds) - long double time_sec; + // measurement of task's time (in seconds) + long double time_sec; }; class Perf { public: - // Init performance analysis with initialized task and initialized data - explicit Perf(std::shared_ptr task_); - // Set task with initialized task and initialized data for performance analysis c - void set_task(std::shared_ptr task_); - // Check performance of full task's pipeline: pre_processing() -> validation() -> run() -> post_processing() - void pipeline_run(std::shared_ptr perfAttr, std::shared_ptr perfResults); - // Check performance of task's run() function - void task_run(std::shared_ptr perfAttr, std::shared_ptr perfResults); + // Init performance analysis with initialized task and initialized data + explicit Perf(std::shared_ptr task_); + // Set task with initialized task and initialized data for performance + // analysis c + void set_task(std::shared_ptr task_); + // Check performance of full task's pipeline: pre_processing() -> + // validation() -> run() -> post_processing() + void pipeline_run(std::shared_ptr perfAttr, + std::shared_ptr perfResults); + // Check performance of task's run() function + void task_run(std::shared_ptr perfAttr, + std::shared_ptr perfResults); + private: - std::shared_ptr task; - static void common_run(std::shared_ptr perfAttr, std::function pipeline, - std::shared_ptr perfResults); + std::shared_ptr task; + static void common_run(std::shared_ptr perfAttr, + std::function pipeline, + std::shared_ptr perfResults); }; } // namespace core diff --git a/modules/core/include/task.hpp b/modules/core/include/task.hpp index c452facd..3add362e 100644 --- a/modules/core/include/task.hpp +++ b/modules/core/include/task.hpp @@ -4,53 +4,54 @@ #define MODULES_CORE_INCLUDE_TASK_HPP_ #include -#include -#include #include +#include #include +#include namespace ppc::core { struct TaskData { - std::vector inputs; - std::vector inputs_count; - std::vector outputs; - std::vector outputs_count; + std::vector inputs; + std::vector inputs_count; + std::vector outputs; + std::vector outputs_count; }; -// Memory of inputs and outputs need to be initialized before create object of Task class +// Memory of inputs and outputs need to be initialized before create object of +// Task class class Task { public: - explicit Task(std::shared_ptr taskData_); + explicit Task(std::shared_ptr taskData_); - // set input and output data - void set_data(std::shared_ptr taskData_); + // set input and output data + void set_data(std::shared_ptr taskData_); - // validation of data and validation of task attributes before running - virtual bool validation() = 0; + // validation of data and validation of task attributes before running + virtual bool validation() = 0; - // pre-processing of input data - virtual bool pre_processing() = 0; + // pre-processing of input data + virtual bool pre_processing() = 0; - // realization of current task - virtual bool run() = 0; + // realization of current task + virtual bool run() = 0; - // post-processing of output data - virtual bool post_processing() = 0; + // post-processing of output data + virtual bool post_processing() = 0; - // get input and output data - [[nodiscard]] std::shared_ptr get_data() const; + // get input and output data + [[nodiscard]] std::shared_ptr get_data() const; - ~Task(); + ~Task(); protected: - void internal_order_test(const std::string &str = __builtin_FUNCTION()); - std::shared_ptr taskData; + void internal_order_test(const std::string &str = __builtin_FUNCTION()); + std::shared_ptr taskData; private: - std::vector functions_order; - std::vector right_functions_order = - {"validation", "pre_processing", "run", "post_processing"}; + std::vector functions_order; + std::vector right_functions_order = { + "validation", "pre_processing", "run", "post_processing"}; }; } // namespace ppc::core diff --git a/modules/core/src/perf.cpp b/modules/core/src/perf.cpp index d1d65aa4..568b9323 100644 --- a/modules/core/src/perf.cpp +++ b/modules/core/src/perf.cpp @@ -1,44 +1,52 @@ // Copyright 2023 Nesterov Alexander -#include -#include #include "core/include/perf.hpp" + +#include +#include + #include "unapproved/unapproved.h" ppc::core::Perf::Perf(std::shared_ptr task_) { - set_task(std::move(task_)); + set_task(std::move(task_)); } void ppc::core::Perf::set_task(std::shared_ptr task_) { - task = std::move(task_); + task = std::move(task_); } -void ppc::core::Perf::pipeline_run(std::shared_ptr perfAttr, - std::shared_ptr perfResults) { - common_run(std::move(perfAttr), [&]() { +void ppc::core::Perf::pipeline_run( + std::shared_ptr perfAttr, + std::shared_ptr perfResults) { + common_run( + std::move(perfAttr), + [&]() { task->validation(); task->pre_processing(); task->run(); task->post_processing(); - }, std::move(perfResults)); + }, + std::move(perfResults)); } -void ppc::core::Perf::task_run(std::shared_ptr perfAttr, - std::shared_ptr perfResults) { - task->validation(); - task->pre_processing(); - common_run(std::move(perfAttr), [&]() { - task->run(); - }, std::move(perfResults)); - task->post_processing(); +void ppc::core::Perf::task_run( + std::shared_ptr perfAttr, + std::shared_ptr perfResults) { + task->validation(); + task->pre_processing(); + common_run( + std::move(perfAttr), [&]() { task->run(); }, std::move(perfResults)); + task->post_processing(); } -void ppc::core::Perf::common_run(std::shared_ptr perfAttr, std::function pipeline, - std::shared_ptr perfResults) { - auto begin = std::chrono::high_resolution_clock::now(); - for (int i = 0; i < perfAttr->num_running; i++) { - pipeline(); - } - auto end = std::chrono::high_resolution_clock::now(); - auto duration = std::chrono::duration_cast(end - begin).count(); - perfResults->time_sec = duration * 1e-9; +void ppc::core::Perf::common_run( + std::shared_ptr perfAttr, std::function pipeline, + std::shared_ptr perfResults) { + auto begin = std::chrono::high_resolution_clock::now(); + for (int i = 0; i < perfAttr->num_running; i++) { + pipeline(); + } + auto end = std::chrono::high_resolution_clock::now(); + auto duration = + std::chrono::duration_cast(end - begin).count(); + perfResults->time_sec = duration * 1e-9; } diff --git a/modules/core/src/task.cpp b/modules/core/src/task.cpp index baab4963..df4b983f 100644 --- a/modules/core/src/task.cpp +++ b/modules/core/src/task.cpp @@ -1,37 +1,38 @@ // Copyright 2023 Nesterov Alexander #include "core/include/task.hpp" -#include + #include +#include void ppc::core::Task::set_data(std::shared_ptr taskData_) { - functions_order.clear(); - taskData = std::move(taskData_); + functions_order.clear(); + taskData = std::move(taskData_); } std::shared_ptr ppc::core::Task::get_data() const { - return taskData; + return taskData; } ppc::core::Task::Task(std::shared_ptr taskData_) { - set_data(std::move(taskData_)); + set_data(std::move(taskData_)); } -void ppc::core::Task::internal_order_test(const std::string& str) { - if (!functions_order.empty() && str == functions_order.back() && str == "run") - return; +void ppc::core::Task::internal_order_test(const std::string& str) { + if (!functions_order.empty() && str == functions_order.back() && str == "run") + return; - functions_order.push_back(str); + functions_order.push_back(str); - for (auto i = 0; i < functions_order.size(); i++) { - if (functions_order[i] != right_functions_order[i % right_functions_order.size()]) { - throw std::invalid_argument("ORDER OF FUCTIONS IS NOT RIGHT: \n" + - std::string("Serial number: ") + std::to_string(i + 1) + "\n" + - std::string("Yours function: ") + functions_order[i] + "\n" + - std::string("Expected function: ") + right_functions_order[i]); - } + for (auto i = 0; i < functions_order.size(); i++) { + if (functions_order[i] != + right_functions_order[i % right_functions_order.size()]) { + throw std::invalid_argument( + "ORDER OF FUCTIONS IS NOT RIGHT: \n" + + std::string("Serial number: ") + std::to_string(i + 1) + "\n" + + std::string("Yours function: ") + functions_order[i] + "\n" + + std::string("Expected function: ") + right_functions_order[i]); } + } } -ppc::core::Task::~Task() { - functions_order.clear(); -} +ppc::core::Task::~Task() { functions_order.clear(); } diff --git a/modules/core/tests/core_tests.cpp b/modules/core/tests/core_tests.cpp index 81c75179..0f9590e3 100644 --- a/modules/core/tests/core_tests.cpp +++ b/modules/core/tests/core_tests.cpp @@ -1,186 +1,195 @@ // Copyright 2023 Nesterov Alexander #include + #include + +#include "core/include/perf.hpp" #include "core/include/task.hpp" #include "core/tests/test_task.hpp" -#include "core/include/perf.hpp" TEST(core_tests, check_int32_t) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], in.size()); } TEST(core_tests, check_validate_func) { - // Create data - std::vector in(20, 1); - std::vector out(2, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(20, 1); + std::vector out(2, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, false); } TEST(core_tests, check_double) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in.size(), 1e-6); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], in.size(), 1e-6); } TEST(core_tests, check_uint8_t) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], in.size()); } TEST(core_tests, check_int64_t) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], in.size()); } TEST(core_tests, check_float) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in.size(), 1e-3); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], in.size(), 1e-3); } TEST(core_tests, check_wrong_order) { - // Create data - std::vector in(20, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::test::TestTask testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - ASSERT_ANY_THROW(testTask.post_processing()); + // Create data + std::vector in(20, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::test::TestTask testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + ASSERT_ANY_THROW(testTask.post_processing()); } TEST(core_tests, check_perf_pipeline) { - // Create data - std::vector in(2000, 1); - std::vector out(1, 0); + // Create data + std::vector in(2000, 1); + std::vector out(1, 0); - // Create TaskData - auto taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); + // Create TaskData + auto taskData = std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); - // Create Task - auto testTask = std::make_shared>(taskData); + // Create Task + auto testTask = std::make_shared>(taskData); - // Create Perf attributes - auto perfAttr = std::make_shared(); - perfAttr->num_running = 10; + // Create Perf attributes + auto perfAttr = std::make_shared(); + perfAttr->num_running = 10; - // Create and init perf results - auto perfResults = std::make_shared(); + // Create and init perf results + auto perfResults = std::make_shared(); - // Create Perf analyzer - ppc::core::Perf perfAnalyzer(testTask); - perfAnalyzer.pipeline_run(perfAttr, perfResults); + // Create Perf analyzer + ppc::core::Perf perfAnalyzer(testTask); + perfAnalyzer.pipeline_run(perfAttr, perfResults); - ASSERT_LE(perfResults->time_sec, 10.0); - EXPECT_EQ(out[0], in.size()); + ASSERT_LE(perfResults->time_sec, 10.0); + EXPECT_EQ(out[0], in.size()); } // TEST(core_tests, check_perf_task) { @@ -196,7 +205,8 @@ TEST(core_tests, check_perf_pipeline) { // taskData->outputs_count.emplace_back(out.size()); // // // Create Task -// auto testTask = std::make_shared>(taskData); +// auto testTask = +// std::make_shared>(taskData); // // // Create Perf attributes // auto perfAttr = std::make_shared(); diff --git a/modules/core/tests/test_task.hpp b/modules/core/tests/test_task.hpp index 56e6d7af..80e29206 100644 --- a/modules/core/tests/test_task.hpp +++ b/modules/core/tests/test_task.hpp @@ -4,50 +4,53 @@ #define MODULES_CORE_TESTS_TEST_TASK_HPP_ #include -#include + #include +#include + #include "core/include/task.hpp" namespace ppc { namespace test { -template +template class TestTask : public ppc::core::Task { public: - explicit TestTask(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - input_ = reinterpret_cast(taskData->inputs[0]); - output_ = reinterpret_cast(taskData->outputs[0]); - output_[0] = 0; - return true; + explicit TestTask(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + input_ = reinterpret_cast(taskData->inputs[0]); + output_ = reinterpret_cast(taskData->outputs[0]); + output_[0] = 0; + return true; + } + + bool validation() override { + internal_order_test(); + if (taskData->outputs_count[0] == 1) { + return true; + } else { + return false; } + } - bool validation() override { - internal_order_test(); - if (taskData->outputs_count[0] == 1) { - return true; - } else { - return false; - } + bool run() override { + internal_order_test(); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + output_[0] += input_[i]; } + return true; + } - bool run() override { - internal_order_test(); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - output_[0] += input_[i]; - } - return true; - } - - bool post_processing() override { - internal_order_test(); - return true; - } + bool post_processing() override { + internal_order_test(); + return true; + } private: - T *input_{}; - T *output_{}; + T *input_{}; + T *output_{}; }; } // namespace test diff --git a/modules/reference/average_of_vector_elements/ref_task.hpp b/modules/reference/average_of_vector_elements/ref_task.hpp index 9963bbe6..5b7cd508 100644 --- a/modules/reference/average_of_vector_elements/ref_task.hpp +++ b/modules/reference/average_of_vector_elements/ref_task.hpp @@ -4,57 +4,62 @@ #define MODULES_REFERENCE_AVERAGE_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ #include -#include + #include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class AverageOfVectorElements : public ppc::core::Task { public: - explicit AverageOfVectorElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - average = 0.0; - return true; + explicit AverageOfVectorElements( + std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + average = 0.0; + return true; + } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - average = static_cast(std::accumulate(input_.begin(), input_.end(), 0.0)); - average /= static_cast(taskData->inputs_count[0]); - return true; - } + bool run() override { + internal_order_test(); + average = static_cast( + std::accumulate(input_.begin(), input_.end(), 0.0)); + average /= static_cast(taskData->inputs_count[0]); + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = average; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = average; + return true; + } private: - std::vector input_; - OutType average; + std::vector input_; + OutType average; }; } // namespace reference diff --git a/modules/reference/average_of_vector_elements/ref_tests.cpp b/modules/reference/average_of_vector_elements/ref_tests.cpp index e553867c..8050fde4 100644 --- a/modules/reference/average_of_vector_elements/ref_tests.cpp +++ b/modules/reference/average_of_vector_elements/ref_tests.cpp @@ -1,133 +1,141 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/average_of_vector_elements/ref_task.hpp" TEST(average_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1.0, 1e-5); + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, false); } TEST(average_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1.123); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1.123, 1e-5); + // Create data + std::vector in(25680, 1.123); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 2.0, 1e-5); + // Create data + std::vector in(255, 2); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 3.0, 1e-5); + // Create data + std::vector in(75836, 3); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 3.0, 1e-5); } TEST(average_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1.5); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::AverageOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1.5, 1e-5); + // Create data + std::vector in(1, 1.5); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::AverageOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 1.5, 1e-5); } diff --git a/modules/reference/max_of_vector_elements/ref_task.hpp b/modules/reference/max_of_vector_elements/ref_task.hpp index a32dd282..15a8b7bf 100644 --- a/modules/reference/max_of_vector_elements/ref_task.hpp +++ b/modules/reference/max_of_vector_elements/ref_task.hpp @@ -4,74 +4,77 @@ #define MODULES_REFERENCE_MAX_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ #include -#include -#include + #include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class MaxOfVectorElements : public ppc::core::Task { public: - explicit MaxOfVectorElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - max = 0.0; - max_index = 0; - return true; + explicit MaxOfVectorElements(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + max = 0.0; + max_index = 0; + return true; + } - bool validation() override { - internal_order_test(); - bool isCountValuesCorrect, isCountIndexesCorrect; - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - isCountValuesCorrect = true; - } else { - isCountValuesCorrect = false; - } - if (taskData->outputs_count[1] == 1) { - isCountIndexesCorrect = true; - } else { - isCountIndexesCorrect = false; - } - - if (isCountValuesCorrect && isCountIndexesCorrect) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + bool isCountValuesCorrect, isCountIndexesCorrect; + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + isCountValuesCorrect = true; + } else { + isCountValuesCorrect = false; } - - bool run() override { - internal_order_test(); - auto result = std::max_element(input_.begin(), input_.end()); - max = static_cast(*result); - max_index = static_cast(std::distance(input_.begin(), result)); - return true; + if (taskData->outputs_count[1] == 1) { + isCountIndexesCorrect = true; + } else { + isCountIndexesCorrect = false; } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = max; - reinterpret_cast(taskData->outputs[1])[0] = max_index; - return true; + if (isCountValuesCorrect && isCountIndexesCorrect) { + return true; + } else { + return false; } + } + + bool run() override { + internal_order_test(); + 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 post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = max; + reinterpret_cast(taskData->outputs[1])[0] = max_index; + return true; + } private: - std::vector input_; - InOutType max; - IndexType max_index; + std::vector input_; + InOutType max; + IndexType max_index; }; } // namespace reference diff --git a/modules/reference/max_of_vector_elements/ref_tests.cpp b/modules/reference/max_of_vector_elements/ref_tests.cpp index a508f711..60fe3a9f 100644 --- a/modules/reference/max_of_vector_elements/ref_tests.cpp +++ b/modules/reference/max_of_vector_elements/ref_tests.cpp @@ -1,181 +1,190 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/max_of_vector_elements/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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 10); - ASSERT_EQ(out_index[0], 328); + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[328] = 10; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 10); + ASSERT_EQ(out_index[0], 328); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(1, 0); + std::vector out_index(2, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1.0001, 1e-6); - ASSERT_EQ(out_index[0], 2); + // Create data + std::vector in(25680, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[2] = 1.0001; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 1.0001, 1e-6); + ASSERT_EQ(out_index[0], 2); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1, 1e-6); - ASSERT_EQ(out_index[0], 0); + // Create data + std::vector in(255, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 1, 1e-6); + ASSERT_EQ(out_index[0], 0); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 256, 1e-6); - ASSERT_EQ(out_index[0], 345); + // Create data + std::vector in(75836, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[345] = 256; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 256, 1e-6); + ASSERT_EQ(out_index[0], 345); } TEST(max_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[0] = 1.01; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MaxOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1.01, 1e-6); - ASSERT_EQ(out_index[0], 0); + // Create data + std::vector in(1, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[0] = 1.01; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MaxOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 1.01, 1e-6); + ASSERT_EQ(out_index[0], 0); } diff --git a/modules/reference/min_of_vector_elements/ref_task.hpp b/modules/reference/min_of_vector_elements/ref_task.hpp index ff4caa0c..f7d59e61 100644 --- a/modules/reference/min_of_vector_elements/ref_task.hpp +++ b/modules/reference/min_of_vector_elements/ref_task.hpp @@ -4,74 +4,77 @@ #define MODULES_REFERENCE_MIN_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ #include -#include -#include + #include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class MinOfVectorElements : public ppc::core::Task { public: - explicit MinOfVectorElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - min = 0.0; - min_index = 0; - return true; + explicit MinOfVectorElements(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + min = 0.0; + min_index = 0; + return true; + } - bool validation() override { - internal_order_test(); - bool isCountValuesCorrect, isCountIndexesCorrect; - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - isCountValuesCorrect = true; - } else { - isCountValuesCorrect = false; - } - if (taskData->outputs_count[1] == 1) { - isCountIndexesCorrect = true; - } else { - isCountIndexesCorrect = false; - } - - if (isCountValuesCorrect && isCountIndexesCorrect) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + bool isCountValuesCorrect, isCountIndexesCorrect; + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + isCountValuesCorrect = true; + } else { + isCountValuesCorrect = false; } - - bool run() override { - internal_order_test(); - auto result = std::min_element(input_.begin(), input_.end()); - min = static_cast(*result); - min_index = static_cast(std::distance(input_.begin(), result)); - return true; + if (taskData->outputs_count[1] == 1) { + isCountIndexesCorrect = true; + } else { + isCountIndexesCorrect = false; } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = min; - reinterpret_cast(taskData->outputs[1])[0] = min_index; - return true; + if (isCountValuesCorrect && isCountIndexesCorrect) { + return true; + } else { + return false; } + } + + bool run() override { + internal_order_test(); + 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 post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = min; + reinterpret_cast(taskData->outputs[1])[0] = min_index; + return true; + } private: - std::vector input_; - InOutType min; - IndexType min_index; + std::vector input_; + InOutType min; + IndexType min_index; }; } // namespace reference diff --git a/modules/reference/min_of_vector_elements/ref_tests.cpp b/modules/reference/min_of_vector_elements/ref_tests.cpp index 0c97e047..e70feda4 100644 --- a/modules/reference/min_of_vector_elements/ref_tests.cpp +++ b/modules/reference/min_of_vector_elements/ref_tests.cpp @@ -1,181 +1,190 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/min_of_vector_elements/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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], -10); - ASSERT_EQ(out_index[0], 328); + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[328] = -10; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], -10); + ASSERT_EQ(out_index[0], 328); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(1, 0); + std::vector out_index(2, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], -1.0001, 1e-6); - ASSERT_EQ(out_index[0], 2); + // Create data + std::vector in(25680, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[2] = -1.0001; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], -1.0001, 1e-6); + ASSERT_EQ(out_index[0], 2); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 1, 1e-6); - ASSERT_EQ(out_index[0], 0); + // Create data + std::vector in(255, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 1, 1e-6); + ASSERT_EQ(out_index[0], 0); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], -256, 1e-6); - ASSERT_EQ(out_index[0], 345); + // Create data + std::vector in(75836, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[345] = -256; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], -256, 1e-6); + ASSERT_EQ(out_index[0], 345); } TEST(min_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1); - std::vector out(1, 0); - std::vector out_index(1, 0); - in[0] = -1.01; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MinOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], -1.01, 1e-6); - ASSERT_EQ(out_index[0], 0); + // Create data + std::vector in(1, 1); + std::vector out(1, 0); + std::vector out_index(1, 0); + in[0] = -1.01; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MinOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], -1.01, 1e-6); + ASSERT_EQ(out_index[0], 0); } diff --git a/modules/reference/most_different_neighbor_elements/ref_task.hpp b/modules/reference/most_different_neighbor_elements/ref_task.hpp index e0f4a5dc..337a8a96 100644 --- a/modules/reference/most_different_neighbor_elements/ref_task.hpp +++ b/modules/reference/most_different_neighbor_elements/ref_task.hpp @@ -4,76 +4,82 @@ #define MODULES_REFERENCE_MOST_DIFFERENT_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ #include -#include -#include -#include + #include +#include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class MostDifferentNeighborElements : public ppc::core::Task { public: - explicit MostDifferentNeighborElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->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; + explicit MostDifferentNeighborElements( + std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->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 validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 2 && taskData->outputs_count[1] == 2) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 2 && taskData->outputs_count[1] == 2) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); + bool run() override { + internal_order_test(); + 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 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]; + 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; - } + r_elem_index = l_elem_index + 1; + r_elem = input_[r_elem_index]; + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = l_elem; - reinterpret_cast(taskData->outputs[0])[1] = r_elem; - reinterpret_cast(taskData->outputs[1])[0] = l_elem_index; - reinterpret_cast(taskData->outputs[1])[1] = r_elem_index; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = l_elem; + reinterpret_cast(taskData->outputs[0])[1] = r_elem; + reinterpret_cast(taskData->outputs[1])[0] = l_elem_index; + reinterpret_cast(taskData->outputs[1])[1] = r_elem_index; + return true; + } private: - std::vector input_; - InOutType l_elem, r_elem; - IndexType l_elem_index, r_elem_index; + std::vector input_; + InOutType l_elem, r_elem; + IndexType l_elem_index, r_elem_index; }; } // namespace reference diff --git a/modules/reference/most_different_neighbor_elements/ref_tests.cpp b/modules/reference/most_different_neighbor_elements/ref_tests.cpp index 249c40f4..71af332f 100644 --- a/modules/reference/most_different_neighbor_elements/ref_tests.cpp +++ b/modules/reference/most_different_neighbor_elements/ref_tests.cpp @@ -1,185 +1,218 @@ // Copyright 2023 Nesterov Alexander #include -#include + #include +#include + #include "core/include/task.hpp" #include "reference/most_different_neighbor_elements/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 (int i = 0; i < in.size(); i++) { in[i] = 2 * i; } - in[234] = 0; in[235] = 4000; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], 0); - EXPECT_EQ(out[1], 4000); - EXPECT_EQ(out_index[0], 234); - EXPECT_EQ(out_index[1], 235); + // Create data + std::vector in(1256, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] = 2 * i; + } + in[234] = 0; + in[235] = 4000; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], 0); + EXPECT_EQ(out[1], 4000); + EXPECT_EQ(out_index[0], 234); + EXPECT_EQ(out_index[1], 235); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, 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 (int i = 0; i < in.size(); i++) { in[i] = i; } - in[189] = -1000.1; in[190] = 9000.9; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], -1000.1, 1e-6); - EXPECT_NEAR(out[1], 9000.9, 1e-6); - EXPECT_EQ(out_index[0], 189); - EXPECT_EQ(out_index[1], 190); + // Create data + std::vector in(25680, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] = i; + } + in[189] = -1000.1; + in[190] = 9000.9; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], -1000.1, 1e-6); + EXPECT_NEAR(out[1], 9000.9, 1e-6); + EXPECT_EQ(out_index[0], 189); + EXPECT_EQ(out_index[1], 190); } 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 (int i = 0; i < in.size(); i++) { - if (i % 2 == 0) { in[i] = -50; } else { in[i] = 50; } + // Create data + std::vector in(250, -1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 2 == 0) { + in[i] = -50; + } else { + in[i] = 50; } - in[5] = 56; in[6] = -56; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], 56); - EXPECT_EQ(out[1], -56); - EXPECT_EQ(out_index[0], 5); - EXPECT_EQ(out_index[1], 6); + } + in[5] = 56; + in[6] = -56; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], 56); + EXPECT_EQ(out[1], -56); + EXPECT_EQ(out_index[0], 5); + EXPECT_EQ(out_index[1], 6); } 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 (int i = 0; i < in.size(); i++) { - if (i % 3 == 0) { in[i] = 10; } - if (i % 3 == 1) { in[i] = 30; } - if (i % 3 == 2) { in[i] = 70; } + // Create data + std::vector in(75836, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 3 == 0) { + in[i] = 10; } - in[20] = -1000; in[21] = 1119; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], -1000); - EXPECT_EQ(out[1], 1119); - EXPECT_EQ(out_index[0], 20); - EXPECT_EQ(out_index[1], 21); + if (i % 3 == 1) { + in[i] = 30; + } + if (i % 3 == 2) { + in[i] = 70; + } + } + in[20] = -1000; + in[21] = 1119; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], -1000); + EXPECT_EQ(out[1], 1119); + EXPECT_EQ(out_index[0], 20); + EXPECT_EQ(out_index[1], 21); } TEST(most_different_neighbor_elements, check_float) { - // Create data - std::vector in(20, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (int i = 0; i < in.size(); i++) { - in[i] += (i + 1.f) * 2.5f; - } - in[0] = 110.001; in[1] = -990.0025; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::MostDifferentNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 110.001, 1e-4); - EXPECT_NEAR(out[1], -990.0025, 1e-4); - EXPECT_EQ(out_index[0], 0); - EXPECT_EQ(out_index[1], 1); + // Create data + std::vector in(20, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] += (i + 1.f) * 2.5f; + } + in[0] = 110.001; + in[1] = -990.0025; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::MostDifferentNeighborElements testTask( + taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 110.001, 1e-4); + EXPECT_NEAR(out[1], -990.0025, 1e-4); + EXPECT_EQ(out_index[0], 0); + EXPECT_EQ(out_index[1], 1); } diff --git a/modules/reference/nearest_neighbor_elements/ref_task.hpp b/modules/reference/nearest_neighbor_elements/ref_task.hpp index b9b91f07..e0c8d83f 100644 --- a/modules/reference/nearest_neighbor_elements/ref_task.hpp +++ b/modules/reference/nearest_neighbor_elements/ref_task.hpp @@ -4,76 +4,82 @@ #define MODULES_REFERENCE_NEAREST_NEIGHBOR_ELEMENTS_REF_TASK_HPP_ #include -#include -#include -#include + #include +#include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class NearestNeighborElements : public ppc::core::Task { public: - explicit NearestNeighborElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->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; + explicit NearestNeighborElements( + std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->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 validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 2 && taskData->outputs_count[1] == 2) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 2 && taskData->outputs_count[1] == 2) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); + bool run() override { + internal_order_test(); + 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 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]; + 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; - } + r_elem_index = l_elem_index + 1; + r_elem = input_[r_elem_index]; + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = l_elem; - reinterpret_cast(taskData->outputs[0])[1] = r_elem; - reinterpret_cast(taskData->outputs[1])[0] = l_elem_index; - reinterpret_cast(taskData->outputs[1])[1] = r_elem_index; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = l_elem; + reinterpret_cast(taskData->outputs[0])[1] = r_elem; + reinterpret_cast(taskData->outputs[1])[0] = l_elem_index; + reinterpret_cast(taskData->outputs[1])[1] = r_elem_index; + return true; + } private: - std::vector input_; - InOutType l_elem, r_elem; - IndexType l_elem_index, r_elem_index; + std::vector input_; + InOutType l_elem, r_elem; + IndexType l_elem_index, r_elem_index; }; } // namespace reference diff --git a/modules/reference/nearest_neighbor_elements/ref_tests.cpp b/modules/reference/nearest_neighbor_elements/ref_tests.cpp index 8df85618..d648709c 100644 --- a/modules/reference/nearest_neighbor_elements/ref_tests.cpp +++ b/modules/reference/nearest_neighbor_elements/ref_tests.cpp @@ -1,185 +1,212 @@ // Copyright 2023 Nesterov Alexander #include -#include + #include +#include + #include "core/include/task.hpp" #include "reference/nearest_neighbor_elements/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 (int i = 0; i < in.size(); i++) { in[i] = 2 * i; } - in[234] = 0; in[235] = 1; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], 0); - EXPECT_EQ(out[1], 1); - EXPECT_EQ(out_index[0], 234); - EXPECT_EQ(out_index[1], 235); + // Create data + std::vector in(1256, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] = 2 * i; + } + in[234] = 0; + in[235] = 1; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], 0); + EXPECT_EQ(out[1], 1); + EXPECT_EQ(out_index[0], 234); + EXPECT_EQ(out_index[1], 235); } 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + std::vector out_index(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, 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 (int i = 0; i < in.size(); i++) { in[i] = 2 * i; } - in[189] = 0.1; in[190] = 0.9; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 0.1, 1e-6); - EXPECT_NEAR(out[1], 0.9, 1e-6); - EXPECT_EQ(out_index[0], 189); - EXPECT_EQ(out_index[1], 190); + // Create data + std::vector in(25680, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] = 2 * i; + } + in[189] = 0.1; + in[190] = 0.9; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 0.1, 1e-6); + EXPECT_NEAR(out[1], 0.9, 1e-6); + EXPECT_EQ(out_index[0], 189); + EXPECT_EQ(out_index[1], 190); } 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 (int i = 0; i < in.size(); i++) { - if (i % 2 == 0) { in[i] = -50; } else { in[i] = 50; } + // Create data + std::vector in(250, -1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 2 == 0) { + in[i] = -50; + } else { + in[i] = 50; } - in[5] = 8; in[6] = -8; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], 8); - EXPECT_EQ(out[1], -8); - EXPECT_EQ(out_index[0], 5); - EXPECT_EQ(out_index[1], 6); + } + in[5] = 8; + in[6] = -8; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], 8); + EXPECT_EQ(out[1], -8); + EXPECT_EQ(out_index[0], 5); + EXPECT_EQ(out_index[1], 6); } 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 (int i = 0; i < in.size(); i++) { - if (i % 3 == 0) { in[i] = 10; } - if (i % 3 == 1) { in[i] = 30; } - if (i % 3 == 2) { in[i] = 70; } + // Create data + std::vector in(75836, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 3 == 0) { + in[i] = 10; } - in[20] = -100; in[21] = -119; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_EQ(out[0], -100); - EXPECT_EQ(out[1], -119); - EXPECT_EQ(out_index[0], 20); - EXPECT_EQ(out_index[1], 21); + if (i % 3 == 1) { + in[i] = 30; + } + if (i % 3 == 2) { + in[i] = 70; + } + } + in[20] = -100; + in[21] = -119; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_EQ(out[0], -100); + EXPECT_EQ(out[1], -119); + EXPECT_EQ(out_index[0], 20); + EXPECT_EQ(out_index[1], 21); } TEST(nearest_neighbor_elements, check_float) { - // Create data - std::vector in(20, 1); - std::vector out(2, 0); - std::vector out_index(2, 0); - for (int i = 0; i < in.size(); i++) { - in[i] += (i + 1.f) * 2.5f; - } - in[0] = 0.001; in[1] = 0.0025; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); - taskData->outputs_count.emplace_back(out_index.size()); - - // Create Task - ppc::reference::NearestNeighborElements testTask(taskData); - bool isValid = testTask.validation(); - EXPECT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], 0.001, 1e-4); - EXPECT_NEAR(out[1], 0.0025, 1e-4); - EXPECT_EQ(out_index[0], 0); - EXPECT_EQ(out_index[1], 1); + // Create data + std::vector in(20, 1); + std::vector out(2, 0); + std::vector out_index(2, 0); + for (int i = 0; i < in.size(); i++) { + in[i] += (i + 1.f) * 2.5f; + } + in[0] = 0.001; + in[1] = 0.0025; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + taskData->outputs.emplace_back(reinterpret_cast(out_index.data())); + taskData->outputs_count.emplace_back(out_index.size()); + + // Create Task + ppc::reference::NearestNeighborElements testTask(taskData); + bool isValid = testTask.validation(); + EXPECT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], 0.001, 1e-4); + EXPECT_NEAR(out[1], 0.0025, 1e-4); + EXPECT_EQ(out_index[0], 0); + EXPECT_EQ(out_index[1], 1); } diff --git a/modules/reference/num_of_alternations_signs/ref_task.hpp b/modules/reference/num_of_alternations_signs/ref_task.hpp index a7531aa5..c20e8d70 100644 --- a/modules/reference/num_of_alternations_signs/ref_task.hpp +++ b/modules/reference/num_of_alternations_signs/ref_task.hpp @@ -4,65 +4,71 @@ #define MODULES_REFERENCE_NUM_OF_ALTERNATIONS_SIGNS_REF_TASK_HPP_ #include -#include -#include -#include + #include +#include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class NumOfAlternationsSigns : public ppc::core::Task { public: - explicit NumOfAlternationsSigns(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - num = 0; - return true; + explicit NumOfAlternationsSigns( + std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + num = 0; + return true; + } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); + bool run() override { + internal_order_test(); + 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()); + 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; - } + num = std::count_if(temp_res.begin(), temp_res.end() - 1, + [](InOutType elem) { return elem < 0; }); + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = num; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = num; + return true; + } private: - std::vector input_; - CountType num; + std::vector input_; + CountType num; }; } // namespace reference diff --git a/modules/reference/num_of_alternations_signs/ref_tests.cpp b/modules/reference/num_of_alternations_signs/ref_tests.cpp index 038aceb1..5a74c59b 100644 --- a/modules/reference/num_of_alternations_signs/ref_tests.cpp +++ b/modules/reference/num_of_alternations_signs/ref_tests.cpp @@ -1,140 +1,152 @@ // Copyright 2023 Nesterov Alexander #include -#include + #include +#include + #include "core/include/task.hpp" #include "reference/num_of_alternations_signs/ref_task.hpp" TEST(num_of_alternations_signs, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - for (int i = 0; i < in.size(); i++) { - if (i % 2 == 0) { in[i] *= -1; } + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 2 == 0) { + in[i] *= -1; } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size() - 1); + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 6); + // Create data + std::vector in(25680, 1); + std::vector out(1, 0); + in[1] = -1; + in[200] = -1; + in[456] = -1; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 6); } TEST(num_of_alternations_signs, check_int8_t) { - // Create data - std::vector in(255, -1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 0); + // Create data + std::vector in(255, -1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 0); } TEST(num_of_alternations_signs, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - for (int i = 500; i < in.size() - 600; i++) { - in[i] *= -1; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 2); + // Create data + std::vector in(75836, 1); + std::vector out(1, 0); + for (int i = 500; i < in.size() - 600; i++) { + in[i] *= -1; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 2); } TEST(num_of_alternations_signs, check_float) { - // Create data - std::vector in(3, 1); - std::vector out(1, 0); - in[1] = -1.0001; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfAlternationsSigns testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 2); + // Create data + std::vector in(3, 1); + std::vector out(1, 0); + in[1] = -1.0001; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfAlternationsSigns testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 2); } diff --git a/modules/reference/num_of_orderly_violations/ref_task.hpp b/modules/reference/num_of_orderly_violations/ref_task.hpp index 1866eec6..32d7128e 100644 --- a/modules/reference/num_of_orderly_violations/ref_task.hpp +++ b/modules/reference/num_of_orderly_violations/ref_task.hpp @@ -4,66 +4,72 @@ #define MODULES_REFERENCE_NUM_OF_ORDERLY_VIOLATIONS_REF_TASK_HPP_ #include -#include -#include -#include + #include +#include +#include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class NumOfOrderlyViolations : public ppc::core::Task { public: - explicit NumOfOrderlyViolations(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - num = 0; - return true; + explicit NumOfOrderlyViolations( + std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + num = 0; + return true; + } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - auto rotate_in = input_; - int rot_left = 1; - rotate(rotate_in.begin(), rotate_in.begin() + rot_left, rotate_in.end()); + bool run() override { + internal_order_test(); + 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; }); + 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; - } + num = std::count_if(temp_res.begin(), temp_res.end() - 1, + [](InOutType elem) { return elem; }); + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = num; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = num; + return true; + } private: - std::vector input_; - CountType num; + std::vector input_; + CountType num; }; } // namespace reference diff --git a/modules/reference/num_of_orderly_violations/ref_tests.cpp b/modules/reference/num_of_orderly_violations/ref_tests.cpp index e6b8b1be..feb744ff 100644 --- a/modules/reference/num_of_orderly_violations/ref_tests.cpp +++ b/modules/reference/num_of_orderly_violations/ref_tests.cpp @@ -1,140 +1,152 @@ // Copyright 2023 Nesterov Alexander #include -#include + #include +#include + #include "core/include/task.hpp" #include "reference/num_of_orderly_violations/ref_task.hpp" TEST(num_of_orderly_violations, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - for (int i = 0; i < in.size(); i++) { - if (i % 2 == 0) { in[i] *= -1; } + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + for (int i = 0; i < in.size(); i++) { + if (i % 2 == 0) { + in[i] *= -1; } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size() / 2 - 1); + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 3); + // Create data + std::vector in(25680, 1); + std::vector out(1, 0); + in[1] = -1; + in[200] = -1; + in[456] = -1; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 3); } TEST(num_of_orderly_violations, check_int8_t) { - // Create data - std::vector in(255, -1); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 0); + // Create data + std::vector in(255, -1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 0); } TEST(num_of_orderly_violations, check_int64_t) { - // Create data - std::vector in(75836, 1); - std::vector out(1, 0); - for (int i = 500; i < in.size() - 600; i++) { - in[i] *= -1; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 1); + // Create data + std::vector in(75836, 1); + std::vector out(1, 0); + for (int i = 500; i < in.size() - 600; i++) { + in[i] *= -1; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 1); } TEST(num_of_orderly_violations, check_float) { - // Create data - std::vector in(3, 1); - std::vector out(1, 0); - in[1] = -1.0001; - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::NumOfOrderlyViolations testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], 1); + // Create data + std::vector in(3, 1); + std::vector out(1, 0); + in[1] = -1.0001; + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::NumOfOrderlyViolations testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], 1); } diff --git a/modules/reference/sum_of_vector_elements/ref_task.hpp b/modules/reference/sum_of_vector_elements/ref_task.hpp index 3b1010f5..a62a5155 100644 --- a/modules/reference/sum_of_vector_elements/ref_task.hpp +++ b/modules/reference/sum_of_vector_elements/ref_task.hpp @@ -4,56 +4,59 @@ #define MODULES_REFERENCE_SUM_OF_VECTOR_ELEMENTS_REF_TASK_HPP_ #include -#include + #include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class SumOfVectorElements : public ppc::core::Task { public: - explicit SumOfVectorElements(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - // Init value for output - sum = 0; - return true; + explicit SumOfVectorElements(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + // Init value for output + sum = 0; + return true; + } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 1) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 1) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - sum = std::accumulate(input_.begin(), input_.end(), 0); - return true; - } + bool run() override { + internal_order_test(); + sum = std::accumulate(input_.begin(), input_.end(), 0); + return true; + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = sum; - return true; - } + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = sum; + return true; + } private: - std::vector input_; - InOutType sum; + std::vector input_; + InOutType sum; }; } // namespace reference diff --git a/modules/reference/sum_of_vector_elements/ref_tests.cpp b/modules/reference/sum_of_vector_elements/ref_tests.cpp index bd200e61..2e29dd17 100644 --- a/modules/reference/sum_of_vector_elements/ref_tests.cpp +++ b/modules/reference/sum_of_vector_elements/ref_tests.cpp @@ -1,121 +1,129 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/sum_of_vector_elements/ref_task.hpp" TEST(sum_of_vector_elements, check_int32_t) { - // Create data - std::vector in(1256, 1); - std::vector out(1, 0); - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(1256, 1); + std::vector out(1, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(125, 1); + std::vector out(2, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, false); } TEST(sum_of_vector_elements, check_double) { - // Create data - std::vector in(25680, 1); - std::vector out(1, 0); - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in.size(), 1e-6); + // Create data + std::vector in(25680, 1); + std::vector out(1, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(255, 1); + std::vector out(1, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in.size()); + // Create data + std::vector in(75836, 1); + std::vector out(1, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(out[0], in.size()); } TEST(sum_of_vector_elements, check_float) { - // Create data - std::vector in(1, 1); - std::vector out(1, 0); - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - // Create Task - ppc::reference::SumOfVectorElements testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in.size(), 1e-3); + // Create data + std::vector in(1, 1); + std::vector out(1, 0); + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + // Create Task + ppc::reference::SumOfVectorElements testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], in.size(), 1e-3); } diff --git a/modules/reference/sum_values_by_rows_matrix/ref_task.hpp b/modules/reference/sum_values_by_rows_matrix/ref_task.hpp index 4f63e4be..b6039c6d 100644 --- a/modules/reference/sum_values_by_rows_matrix/ref_task.hpp +++ b/modules/reference/sum_values_by_rows_matrix/ref_task.hpp @@ -4,65 +4,70 @@ #define MODULES_REFERENCE_SUM_VALUES_BY_ROWS_MATRIX_REF_TASK_HPP_ #include -#include + #include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class SumValuesByRowsMatrix : public ppc::core::Task { public: - explicit SumValuesByRowsMatrix(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector(taskData->inputs_count[0]); - auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); - for (int i = 0; i < taskData->inputs_count[0]; i++) { - input_[i] = tmp_ptr[i]; - } - rows = reinterpret_cast(taskData->inputs[1])[0]; - cols = reinterpret_cast(taskData->inputs[1])[1]; - - // Init value for output - sum_ = std::vector(cols, 0.f); - return true; + explicit SumValuesByRowsMatrix(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector(taskData->inputs_count[0]); + auto tmp_ptr = reinterpret_cast(taskData->inputs[0]); + for (int i = 0; i < taskData->inputs_count[0]; i++) { + input_[i] = tmp_ptr[i]; } + rows = reinterpret_cast(taskData->inputs[1])[0]; + cols = reinterpret_cast(taskData->inputs[1])[1]; + + // Init value for output + sum_ = std::vector(cols, 0.f); + return true; + } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->inputs_count[1] == 2 && - taskData->outputs_count[0] == reinterpret_cast(taskData->inputs[1])[0]) { - return true; - } else { - return false; - } + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->inputs_count[1] == 2 && + taskData->outputs_count[0] == + reinterpret_cast(taskData->inputs[1])[0]) { + return true; + } else { + return false; } + } - bool run() override { - internal_order_test(); - for (int i = 0; i < rows; i++) { - sum_[i] = std::accumulate(input_.begin() + cols * i, input_.begin() + cols * (i + 1), 0.f); - } - return true; + bool run() override { + internal_order_test(); + for (int i = 0; i < rows; i++) { + sum_[i] = std::accumulate(input_.begin() + cols * i, + input_.begin() + cols * (i + 1), 0.f); } + return true; + } - bool post_processing() override { - internal_order_test(); - for (IndexType i = 0; i < rows; i++) { - reinterpret_cast(taskData->outputs[0])[i] = sum_[i]; - } - return true; + bool post_processing() override { + internal_order_test(); + for (IndexType i = 0; i < rows; i++) { + reinterpret_cast(taskData->outputs[0])[i] = sum_[i]; } + return true; + } private: - std::vector input_; - IndexType rows, cols; - std::vector sum_; + std::vector input_; + IndexType rows, cols; + std::vector sum_; }; } // namespace reference diff --git a/modules/reference/sum_values_by_rows_matrix/ref_tests.cpp b/modules/reference/sum_values_by_rows_matrix/ref_tests.cpp index 54ad6a7e..4e2a8672 100644 --- a/modules/reference/sum_values_by_rows_matrix/ref_tests.cpp +++ b/modules/reference/sum_values_by_rows_matrix/ref_tests.cpp @@ -1,193 +1,203 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/sum_values_by_rows_matrix/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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - for (int i = 0; i < in_index[0]; i++) { - ASSERT_EQ(out[0], 2 * in_index[0]); - } + // Create data + std::vector in(1369, 2); + std::vector in_index(2, 37); + std::vector out(37, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + for (int i = 0; i < in_index[0]; i++) { + ASSERT_EQ(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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(1369, 2); + std::vector in_index(2, 37); + std::vector out(39, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - auto isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in(1369, 2); + std::vector in_index(3, 37); + std::vector out(37, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + auto isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - for (int i = 0; i < in_index[0]; i++) { - EXPECT_NEAR(out[i], 1.0, 1e-6); - } + // Create data + std::vector in(1406, 1.0 / 38.0); + std::vector in_index = {37, 38}; + std::vector out(37, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + for (int 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 (auto i = 0; i < in.size(); ++i) { - in[i] = i % 2 ? -2 : 2; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - for (int i = 0; i < in_index[0]; i++) { - ASSERT_EQ(out[0], 0); - } + // Create data + std::vector in(1406); + std::vector in_index = {37, 38}; + std::vector out(37, 0); + for (auto i = 0; i < in.size(); ++i) { + in[i] = i % 2 ? -2 : 2; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + for (int 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 (auto i = 0; i < in.size(); ++i) { - in[i] = (i % 38) + 1; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - for (int i = 0; i < in_index[0]; i++) { - ASSERT_EQ(out[0], (in_index[1] * (in_index[1] + 1)) / 2); - } + // Create data + std::vector in(1406); + std::vector in_index = {37, 38}; + std::vector out(37, 0); + for (auto i = 0; i < in.size(); ++i) { + in[i] = (i % 38) + 1; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + for (int i = 0; i < in_index[0]; i++) { + ASSERT_EQ(out[0], (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); - for (auto i = 0; i < in.size(); ++i) { - in[i] = static_cast((i % 38) + 1); - in[i] *= in[i]; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in.data())); - taskData->inputs_count.emplace_back(in.size()); - taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); - taskData->inputs_count.emplace_back(in_index.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::SumValuesByRowsMatrix testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - for (int 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); - } + // Create data + std::vector in(1406); + std::vector in_index = {37, 38}; + std::vector out(37, 0); + for (auto i = 0; i < in.size(); ++i) { + in[i] = static_cast((i % 38) + 1); + in[i] *= in[i]; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in.data())); + taskData->inputs_count.emplace_back(in.size()); + taskData->inputs.emplace_back(reinterpret_cast(in_index.data())); + taskData->inputs_count.emplace_back(in_index.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::SumValuesByRowsMatrix testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + for (int 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/reference/vector_dot_product/ref_task.hpp b/modules/reference/vector_dot_product/ref_task.hpp index 730b5287..8c8ae409 100644 --- a/modules/reference/vector_dot_product/ref_task.hpp +++ b/modules/reference/vector_dot_product/ref_task.hpp @@ -4,61 +4,65 @@ #define MODULES_REFERENCE_VECTOR_DOT_PRODUCT_REF_TASK_HPP_ #include -#include + #include #include +#include + #include "core/include/task.hpp" namespace ppc { namespace reference { -template +template class VectorDotProduct : public ppc::core::Task { public: - explicit VectorDotProduct(std::shared_ptr taskData_) : Task(taskData_) {} - bool pre_processing() override { - internal_order_test(); - // Init vectors - input_ = std::vector< std::vector >(2); - for (int i = 0; i < input_.size(); i++) { - input_[i] = std::vector(taskData->inputs_count[i]); - auto tmp_ptr_ = reinterpret_cast(taskData->inputs[i]); - for (int j = 0; j < taskData->inputs_count[i]; j++) { - input_[i][j] = tmp_ptr_[j]; - } - } - - // Init value for output - dor_product = 0; - return true; + explicit VectorDotProduct(std::shared_ptr taskData_) + : Task(taskData_) {} + bool pre_processing() override { + internal_order_test(); + // Init vectors + input_ = std::vector >(2); + for (int i = 0; i < input_.size(); i++) { + input_[i] = std::vector(taskData->inputs_count[i]); + auto tmp_ptr_ = reinterpret_cast(taskData->inputs[i]); + for (int j = 0; j < taskData->inputs_count[i]; j++) { + input_[i][j] = tmp_ptr_[j]; + } } - bool validation() override { - internal_order_test(); - // Check count elements of output - if (taskData->outputs_count[0] == 1 && - taskData->inputs_count[0] == taskData->inputs_count[1]) { - return true; - } else { - return false; - } - } + // Init value for output + dor_product = 0; + return true; + } - bool run() override { - internal_order_test(); - dor_product = std::inner_product(input_[0].begin(), input_[0].end(), input_[1].begin(), 0.0); - return true; + bool validation() override { + internal_order_test(); + // Check count elements of output + if (taskData->outputs_count[0] == 1 && + taskData->inputs_count[0] == taskData->inputs_count[1]) { + return true; + } else { + return false; } + } - bool post_processing() override { - internal_order_test(); - reinterpret_cast(taskData->outputs[0])[0] = dor_product; - return true; - } + bool run() override { + internal_order_test(); + dor_product = std::inner_product(input_[0].begin(), input_[0].end(), + input_[1].begin(), 0.0); + return true; + } + + bool post_processing() override { + internal_order_test(); + reinterpret_cast(taskData->outputs[0])[0] = dor_product; + return true; + } private: - std::vector< std::vector > input_; - InOutType dor_product; + std::vector > input_; + InOutType dor_product; }; } // namespace reference diff --git a/modules/reference/vector_dot_product/ref_tests.cpp b/modules/reference/vector_dot_product/ref_tests.cpp index d2bb517b..902589f3 100644 --- a/modules/reference/vector_dot_product/ref_tests.cpp +++ b/modules/reference/vector_dot_product/ref_tests.cpp @@ -1,183 +1,196 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "core/include/task.hpp" #include "reference/vector_dot_product/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 (int i = 0; i < count_data; i++) { - in1[i] = i + 1; in2[i] = i + 1; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], (count_data * (count_data + 1) * (2 * count_data + 1)) / 6); + // 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 (int i = 0; i < count_data; i++) { + in1[i] = i + 1; + in2[i] = i + 1; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in1(125, 1); + std::vector in2(125, 1); + std::vector out(2, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, false); + // Create data + std::vector in1(125, 1); + std::vector in2(124, 1); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, 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 TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in1.size() * 1.1 * 1.3, 1e-6); + // Create data + std::vector in1(25680, 1.1); + std::vector in2(25680, 1.3); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + 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 (int i = 0; i < in1.size(); ++i) { - in1[i] = in2[i] = (i % 2 == 0) ? 1 : -1; - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], in1.size()); + // Create data + std::vector in1(126, 1); + std::vector in2(126, 1); + std::vector out(1, 0); + for (int i = 0; i < in1.size(); ++i) { + in1[i] = in2[i] = (i % 2 == 0) ? 1 : -1; + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ(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 (int i = 0; i < count_data; i++) { - in1[i] = i + 1; in2[i] = (i + 1) * (i + 1); - } - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - ASSERT_EQ(out[0], (count_data * count_data * (count_data + 1) * (count_data + 1)) / 4); + // 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 (int i = 0; i < count_data; i++) { + in1[i] = i + 1; + in2[i] = (i + 1) * (i + 1); + } + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + ASSERT_EQ( + out[0], + (count_data * count_data * (count_data + 1) * (count_data + 1)) / 4); } TEST(vector_dot_product, check_float) { - // Create data - std::vector in1(1, -1.3); - std::vector in2(1, 1.2); - std::vector out(1, 0); - - // Create TaskData - std::shared_ptr taskData = std::make_shared(); - taskData->inputs.emplace_back(reinterpret_cast(in1.data())); - taskData->inputs_count.emplace_back(in1.size()); - taskData->inputs.emplace_back(reinterpret_cast(in2.data())); - taskData->inputs_count.emplace_back(in2.size()); - taskData->outputs.emplace_back(reinterpret_cast(out.data())); - taskData->outputs_count.emplace_back(out.size()); - - // Create Task - ppc::reference::VectorDotProduct testTask(taskData); - bool isValid = testTask.validation(); - ASSERT_EQ(isValid, true); - testTask.pre_processing(); - testTask.run(); - testTask.post_processing(); - EXPECT_NEAR(out[0], in1.size() * (-1.3) * 1.2, 1e-3); + // Create data + std::vector in1(1, -1.3); + std::vector in2(1, 1.2); + std::vector out(1, 0); + + // Create TaskData + std::shared_ptr taskData = + std::make_shared(); + taskData->inputs.emplace_back(reinterpret_cast(in1.data())); + taskData->inputs_count.emplace_back(in1.size()); + taskData->inputs.emplace_back(reinterpret_cast(in2.data())); + taskData->inputs_count.emplace_back(in2.size()); + taskData->outputs.emplace_back(reinterpret_cast(out.data())); + taskData->outputs_count.emplace_back(out.size()); + + // Create Task + ppc::reference::VectorDotProduct testTask(taskData); + bool isValid = testTask.validation(); + ASSERT_EQ(isValid, true); + testTask.pre_processing(); + testTask.run(); + testTask.post_processing(); + EXPECT_NEAR(out[0], in1.size() * (-1.3) * 1.2, 1e-3); } diff --git a/tasks/examples/test_mpi/main.cpp b/tasks/examples/test_mpi/main.cpp index 41947228..c8da17a7 100644 --- a/tasks/examples/test_mpi/main.cpp +++ b/tasks/examples/test_mpi/main.cpp @@ -1,104 +1,107 @@ // Copyright 2023 Nesterov Alexander #include + +#include +#include #include + #include "./ops_mpi.h" -#include -#include TEST(Parallel_Operations_MPI, Test_Sum) { - boost::mpi::communicator world; - std::vector global_vec; - const int count_size_vector = 120; + boost::mpi::communicator world; + std::vector global_vec; + const int count_size_vector = 120; - if (world.rank() == 0) { - global_vec = getRandomVector(count_size_vector); - } + if (world.rank() == 0) { + global_vec = getRandomVector(count_size_vector); + } - int global_sum = getParallelOperations(global_vec, count_size_vector, "+"); + int global_sum = getParallelOperations(global_vec, count_size_vector, "+"); - if (world.rank() == 0) { - int reference_sum = getSequentialOperations(global_vec, "+"); - ASSERT_EQ(reference_sum, global_sum); - } + if (world.rank() == 0) { + int reference_sum = getSequentialOperations(global_vec, "+"); + ASSERT_EQ(reference_sum, global_sum); + } } TEST(Parallel_Operations_MPI, Test_Diff) { - boost::mpi::communicator world; - std::vector global_vec; - const int count_size_vector = 120; + boost::mpi::communicator world; + std::vector global_vec; + const int count_size_vector = 120; - if (world.rank() == 0) { - global_vec = getRandomVector(count_size_vector); - } + if (world.rank() == 0) { + global_vec = getRandomVector(count_size_vector); + } - int global_diff = getParallelOperations(global_vec, count_size_vector, "-"); + int global_diff = getParallelOperations(global_vec, count_size_vector, "-"); - if (world.rank() == 0) { - int reference_diff = getSequentialOperations(global_vec, "-"); - ASSERT_EQ(reference_diff, global_diff); - } + if (world.rank() == 0) { + int reference_diff = getSequentialOperations(global_vec, "-"); + ASSERT_EQ(reference_diff, global_diff); + } } TEST(Parallel_Operations_MPI, Test_Diff_2) { - boost::mpi::communicator world; - std::vector global_vec; - const int count_size_vector = 120; + boost::mpi::communicator world; + std::vector global_vec; + const int count_size_vector = 120; - if (world.rank() == 0) { - global_vec = getRandomVector(count_size_vector); - } + if (world.rank() == 0) { + global_vec = getRandomVector(count_size_vector); + } - int global_diff = getParallelOperations(global_vec, count_size_vector, "-"); + int global_diff = getParallelOperations(global_vec, count_size_vector, "-"); - if (world.rank() == 0) { - int reference_diff = getSequentialOperations(global_vec, "-"); - ASSERT_EQ(reference_diff, global_diff); - } + if (world.rank() == 0) { + int reference_diff = getSequentialOperations(global_vec, "-"); + ASSERT_EQ(reference_diff, global_diff); + } } TEST(Parallel_Operations_MPI, Test_Max) { - boost::mpi::communicator world; - std::vector global_vec; - const int count_size_vector = 120; + boost::mpi::communicator world; + std::vector global_vec; + const int count_size_vector = 120; - if (world.rank() == 0) { - global_vec = getRandomVector(count_size_vector); - } + if (world.rank() == 0) { + global_vec = getRandomVector(count_size_vector); + } - int global_max; - global_max = getParallelOperations(global_vec, count_size_vector, "max"); + int global_max; + global_max = getParallelOperations(global_vec, count_size_vector, "max"); - if (world.rank() == 0) { - int reference_max = getSequentialOperations(global_vec, "max"); - ASSERT_EQ(reference_max, global_max); - } + if (world.rank() == 0) { + int reference_max = getSequentialOperations(global_vec, "max"); + ASSERT_EQ(reference_max, global_max); + } } TEST(Parallel_Operations_MPI, Test_Max_2) { - boost::mpi::communicator world; - std::vector global_vec; - const int count_size_vector = 120; + boost::mpi::communicator world; + std::vector global_vec; + const int count_size_vector = 120; - if (world.rank() == 0) { - global_vec = getRandomVector(count_size_vector); - } + if (world.rank() == 0) { + global_vec = getRandomVector(count_size_vector); + } - int global_max; - global_max = getParallelOperations(global_vec, count_size_vector, "max"); + int global_max; + global_max = getParallelOperations(global_vec, count_size_vector, "max"); - if (world.rank() == 0) { - int reference_max = getSequentialOperations(global_vec, "max"); - ASSERT_EQ(reference_max, global_max); - } + if (world.rank() == 0) { + int reference_max = getSequentialOperations(global_vec, "max"); + ASSERT_EQ(reference_max, global_max); + } } int main(int argc, char** argv) { - boost::mpi::environment env(argc, argv); - boost::mpi::communicator world; - ::testing::InitGoogleTest(&argc, argv); - ::testing::TestEventListeners& listeners = ::testing::UnitTest::GetInstance()->listeners(); - if (world.rank() != 0) { - delete listeners.Release(listeners.default_result_printer()); - } - return RUN_ALL_TESTS(); + boost::mpi::environment env(argc, argv); + boost::mpi::communicator world; + ::testing::InitGoogleTest(&argc, argv); + ::testing::TestEventListeners& listeners = + ::testing::UnitTest::GetInstance()->listeners(); + if (world.rank() != 0) { + delete listeners.Release(listeners.default_result_printer()); + } + return RUN_ALL_TESTS(); } diff --git a/tasks/examples/test_mpi/ops_mpi.cpp b/tasks/examples/test_mpi/ops_mpi.cpp index bad6d005..35db2554 100644 --- a/tasks/examples/test_mpi/ops_mpi.cpp +++ b/tasks/examples/test_mpi/ops_mpi.cpp @@ -1,67 +1,70 @@ // Copyright 2023 Nesterov Alexander -#include -#include -#include +#include "examples/test_mpi/ops_mpi.h" + #include -#include -#include #include -#include "examples/test_mpi/ops_mpi.h" +#include +#include +#include +#include +#include std::vector getRandomVector(int sz) { - std::random_device dev; - std::mt19937 gen(dev()); - std::vector vec(sz); - for (int i = 0; i < sz; i++) { vec[i] = gen() % 100; } - return vec; + std::random_device dev; + std::mt19937 gen(dev()); + std::vector vec(sz); + for (int i = 0; i < sz; i++) { + vec[i] = gen() % 100; + } + return vec; } int getSequentialOperations(std::vector vec, const std::string& ops) { - const int sz = vec.size(); - int reduction_elem = 0; - if (ops == "+") { - for (int i = 0; i < sz; i++) { - reduction_elem += vec[i]; - } - } else if (ops == "-") { - for (int i = 0; i < sz; i++) { - reduction_elem -= vec[i]; - } - } else if (ops == "max") { - reduction_elem = vec[0]; - for (int i = 1; i < sz; i++) { - reduction_elem = std::max(reduction_elem, vec[i]); - } + const int sz = vec.size(); + int reduction_elem = 0; + if (ops == "+") { + for (int i = 0; i < sz; i++) { + reduction_elem += vec[i]; + } + } else if (ops == "-") { + for (int i = 0; i < sz; i++) { + reduction_elem -= vec[i]; } - return reduction_elem; + } else if (ops == "max") { + reduction_elem = vec[0]; + for (int i = 1; i < sz; i++) { + reduction_elem = std::max(reduction_elem, vec[i]); + } + } + return reduction_elem; } -int getParallelOperations(std::vector global_vec, - int count_size_vector, const std::string& ops) { - boost::mpi::communicator world; - const int delta = count_size_vector / world.size(); +int getParallelOperations(std::vector global_vec, int count_size_vector, + const std::string& ops) { + boost::mpi::communicator world; + const int delta = count_size_vector / world.size(); - if (world.rank() == 0) { - for (int proc = 1; proc < world.size(); proc++) { - world.send(proc, 0, global_vec.data() + proc * delta, delta); - } + if (world.rank() == 0) { + for (int proc = 1; proc < world.size(); proc++) { + world.send(proc, 0, global_vec.data() + proc * delta, delta); } + } - std::vector local_vec(delta); - if (world.rank() == 0) { - local_vec = std::vector(global_vec.begin(), - global_vec.begin() + delta); - } else { - world.recv(0, 0, local_vec.data(), delta); - } + std::vector local_vec(delta); + if (world.rank() == 0) { + local_vec = + std::vector(global_vec.begin(), global_vec.begin() + delta); + } else { + world.recv(0, 0, local_vec.data(), delta); + } - int global_sum = 0; - int local_sum = getSequentialOperations(local_vec, ops); - if (ops == "+" || ops == "-") { - reduce(world, local_sum, global_sum, std::plus(), 0); - } - if (ops == "max") { - reduce(world, local_sum, global_sum, boost::mpi::maximum(), 0); - } - return global_sum; + int global_sum = 0; + int local_sum = getSequentialOperations(local_vec, ops); + if (ops == "+" || ops == "-") { + reduce(world, local_sum, global_sum, std::plus(), 0); + } + if (ops == "max") { + reduce(world, local_sum, global_sum, boost::mpi::maximum(), 0); + } + return global_sum; } diff --git a/tasks/examples/test_mpi/ops_mpi.h b/tasks/examples/test_mpi/ops_mpi.h index 24ec98e4..72f8c036 100644 --- a/tasks/examples/test_mpi/ops_mpi.h +++ b/tasks/examples/test_mpi/ops_mpi.h @@ -2,12 +2,12 @@ #ifndef TASKS_EXAMPLES_TEST_MPI_OPS_MPI_H_ #define TASKS_EXAMPLES_TEST_MPI_OPS_MPI_H_ -#include #include +#include -std::vector getRandomVector(int sz); -int getParallelOperations(std::vector global_vec, - int count_size_vector, const std::string& ops); +std::vector getRandomVector(int sz); +int getParallelOperations(std::vector global_vec, int count_size_vector, + const std::string& ops); int getSequentialOperations(std::vector vec, const std::string& ops); #endif // TASKS_EXAMPLES_TEST_MPI_OPS_MPI_H_ diff --git a/tasks/examples/test_omp/main.cpp b/tasks/examples/test_omp/main.cpp index 5b7aad57..800a6bb6 100644 --- a/tasks/examples/test_omp/main.cpp +++ b/tasks/examples/test_omp/main.cpp @@ -1,44 +1,46 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "./ops_omp.h" TEST(Parallel_Operations_OpenMP, Test_Sum) { - std::vector vec = getRandomVector(100); - int sequential_sum = getSequentialOperations(vec, "+"); - int parallel_sum = getParallelOperations(vec, "+"); - ASSERT_EQ(sequential_sum, parallel_sum); + std::vector vec = getRandomVector(100); + int sequential_sum = getSequentialOperations(vec, "+"); + int parallel_sum = getParallelOperations(vec, "+"); + ASSERT_EQ(sequential_sum, parallel_sum); } TEST(Parallel_Operations_OpenMP, Test_Diff) { - std::vector vec = getRandomVector(100); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + std::vector vec = getRandomVector(100); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } TEST(Parallel_Operations_OpenMP, Test_Diff_2) { - std::vector vec = getRandomVector(10); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + std::vector vec = getRandomVector(10); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } TEST(Parallel_Operations_OpenMP, Test_Mult) { - std::vector vec = getRandomVector(10); - int sequential_mult = getSequentialOperations(vec, "*"); - int parallel_mult = getParallelOperations(vec, "*"); - ASSERT_EQ(sequential_mult, parallel_mult); + std::vector vec = getRandomVector(10); + int sequential_mult = getSequentialOperations(vec, "*"); + int parallel_mult = getParallelOperations(vec, "*"); + ASSERT_EQ(sequential_mult, parallel_mult); } TEST(Parallel_Operations_OpenMP, Test_Mult_2) { - std::vector vec = getRandomVector(5); - int sequential_mult = getSequentialOperations(vec, "*"); - int parallel_mult = getParallelOperations(vec, "*"); - ASSERT_EQ(sequential_mult, parallel_mult); + std::vector vec = getRandomVector(5); + int sequential_mult = getSequentialOperations(vec, "*"); + int parallel_mult = getParallelOperations(vec, "*"); + ASSERT_EQ(sequential_mult, parallel_mult); } int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tasks/examples/test_omp/ops_omp.cpp b/tasks/examples/test_omp/ops_omp.cpp index a81f78a7..7eec881e 100644 --- a/tasks/examples/test_omp/ops_omp.cpp +++ b/tasks/examples/test_omp/ops_omp.cpp @@ -1,59 +1,63 @@ // Copyright 2023 Nesterov Alexander +#include "examples/test_omp/ops_omp.h" + #include -#include -#include -#include + #include -#include "examples/test_omp/ops_omp.h" +#include +#include +#include -std::vector getRandomVector(int sz) { - std::random_device dev; - std::mt19937 gen(dev()); - std::vector vec(sz); - for (int i = 0; i < sz; i++) { vec[i] = gen() % 100; } - return vec; +std::vector getRandomVector(int sz) { + std::random_device dev; + std::mt19937 gen(dev()); + std::vector vec(sz); + for (int i = 0; i < sz; i++) { + vec[i] = gen() % 100; + } + return vec; } int getParallelOperations(std::vector vec, const std::string& ops) { - const int sz = vec.size(); - int reduction_elem = 1; - double start = omp_get_wtime(); - if (ops == "+") { - #pragma omp parallel for reduction(+:reduction_elem) - for (int i = 0; i < sz; i++) { - reduction_elem += vec[i]; - } - } else if (ops == "-") { - #pragma omp parallel for reduction(-:reduction_elem) - for (int i = 0; i < sz; i++) { - reduction_elem -= vec[i]; - } - } else if (ops == "*") { - #pragma omp parallel for reduction(*:reduction_elem) - for (int i = 0; i < sz; i++) { - reduction_elem *= vec[i]; - } + const int sz = vec.size(); + int reduction_elem = 1; + double start = omp_get_wtime(); + if (ops == "+") { +#pragma omp parallel for reduction(+ : reduction_elem) + for (int i = 0; i < sz; i++) { + reduction_elem += vec[i]; + } + } else if (ops == "-") { +#pragma omp parallel for reduction(- : reduction_elem) + for (int i = 0; i < sz; i++) { + reduction_elem -= vec[i]; } - double finish = omp_get_wtime(); - std::cout << "How measure time in OpenMP: " << finish - start << std::endl; - return reduction_elem; + } else if (ops == "*") { +#pragma omp parallel for reduction(* : reduction_elem) + for (int i = 0; i < sz; i++) { + reduction_elem *= vec[i]; + } + } + double finish = omp_get_wtime(); + std::cout << "How measure time in OpenMP: " << finish - start << std::endl; + return reduction_elem; } int getSequentialOperations(std::vector vec, const std::string& ops) { - const int sz = vec.size(); - int reduction_elem = 1; - if (ops == "+") { - for (int i = 0; i < sz; i++) { - reduction_elem += vec[i]; - } - } else if (ops == "-") { - for (int i = 0; i < sz; i++) { - reduction_elem -= vec[i]; - } - } else if (ops == "*") { - for (int i = 0; i < sz; i++) { - reduction_elem *= vec[i]; - } + const int sz = vec.size(); + int reduction_elem = 1; + if (ops == "+") { + for (int i = 0; i < sz; i++) { + reduction_elem += vec[i]; + } + } else if (ops == "-") { + for (int i = 0; i < sz; i++) { + reduction_elem -= vec[i]; + } + } else if (ops == "*") { + for (int i = 0; i < sz; i++) { + reduction_elem *= vec[i]; } - return reduction_elem; + } + return reduction_elem; } diff --git a/tasks/examples/test_omp/ops_omp.h b/tasks/examples/test_omp/ops_omp.h index 1b0c9cb4..09430d08 100644 --- a/tasks/examples/test_omp/ops_omp.h +++ b/tasks/examples/test_omp/ops_omp.h @@ -2,10 +2,10 @@ #ifndef TASKS_EXAMPLES_TEST_OMP_OPS_OMP_H_ #define TASKS_EXAMPLES_TEST_OMP_OPS_OMP_H_ -#include #include +#include -std::vector getRandomVector(int sz); +std::vector getRandomVector(int sz); int getParallelOperations(std::vector vec, const std::string& ops); int getSequentialOperations(std::vector vec, const std::string& ops); diff --git a/tasks/examples/test_seq/main.cpp b/tasks/examples/test_seq/main.cpp index e4610865..34085018 100644 --- a/tasks/examples/test_seq/main.cpp +++ b/tasks/examples/test_seq/main.cpp @@ -1,48 +1,49 @@ // Copyright 2023 Nesterov Alexander #include + #include TEST(Sequential, Test_Sum_10) { - const int count = 10; - int sum = 0; - for (size_t i = 0; i < count; i++) { - sum++; - } - ASSERT_EQ(count, sum); + const int count = 10; + int sum = 0; + for (size_t i = 0; i < count; i++) { + sum++; + } + ASSERT_EQ(count, sum); } TEST(Sequential, Test_Sum_20) { - const int count = 20; - int sum = 0; - for (size_t i = 0; i < count; i++) { - sum++; - } - ASSERT_EQ(count, sum); + const int count = 20; + int sum = 0; + for (size_t i = 0; i < count; i++) { + sum++; + } + ASSERT_EQ(count, sum); } TEST(Sequential, Test_Sum_50) { - const int count = 20; - int sum = 0; - for (size_t i = 0; i < count; i++) { - sum++; - } - ASSERT_EQ(count, sum); + const int count = 20; + int sum = 0; + for (size_t i = 0; i < count; i++) { + sum++; + } + ASSERT_EQ(count, sum); } TEST(Sequential, Test_Sum_70) { - const int count = 20; - int sum = 0; - for (size_t i = 0; i < count; i++) { - sum++; - } - ASSERT_EQ(count, sum); + const int count = 20; + int sum = 0; + for (size_t i = 0; i < count; i++) { + sum++; + } + ASSERT_EQ(count, sum); } TEST(Sequential, Test_Sum_100) { - const int count = 100; - int sum = 0; - for (size_t i = 0; i < count; i++) { - sum++; - } - ASSERT_EQ(count, sum); + const int count = 100; + int sum = 0; + for (size_t i = 0; i < count; i++) { + sum++; + } + ASSERT_EQ(count, sum); } diff --git a/tasks/examples/test_std/main.cpp b/tasks/examples/test_std/main.cpp index 20571e6d..45e7f206 100644 --- a/tasks/examples/test_std/main.cpp +++ b/tasks/examples/test_std/main.cpp @@ -1,50 +1,52 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "../../../3rdparty/unapproved/unapproved.h" #include "./ops_std.h" TEST(Parallel_Operations_Std_Threads, Test_Sum) { - const int nthreads = std::thread::hardware_concurrency() * 10; - std::vector vec = getRandomVector(nthreads); - int sequential_sum = getSequentialOperations(vec, "+"); - int parallel_sum = getParallelOperations(vec, "+"); - ASSERT_EQ(sequential_sum, parallel_sum); + const int nthreads = std::thread::hardware_concurrency() * 10; + std::vector vec = getRandomVector(nthreads); + int sequential_sum = getSequentialOperations(vec, "+"); + int parallel_sum = getParallelOperations(vec, "+"); + ASSERT_EQ(sequential_sum, parallel_sum); } TEST(Parallel_Operations_Std_Threads, Test_Sum_2) { - const int nthreads = std::thread::hardware_concurrency() * 11; - std::vector vec = getRandomVector(nthreads); - int sequential_sum = getSequentialOperations(vec, "+"); - int parallel_sum = getParallelOperations(vec, "+"); - ASSERT_EQ(sequential_sum, parallel_sum); + const int nthreads = std::thread::hardware_concurrency() * 11; + std::vector vec = getRandomVector(nthreads); + int sequential_sum = getSequentialOperations(vec, "+"); + int parallel_sum = getParallelOperations(vec, "+"); + ASSERT_EQ(sequential_sum, parallel_sum); } TEST(Parallel_Operations_Std_Threads, Test_Sum_3) { - const int nthreads = std::thread::hardware_concurrency() * 13; - std::vector vec = getRandomVector(nthreads); - int sequential_sum = getSequentialOperations(vec, "+"); - int parallel_sum = getParallelOperations(vec, "+"); - ASSERT_EQ(sequential_sum, parallel_sum); + const int nthreads = std::thread::hardware_concurrency() * 13; + std::vector vec = getRandomVector(nthreads); + int sequential_sum = getSequentialOperations(vec, "+"); + int parallel_sum = getParallelOperations(vec, "+"); + ASSERT_EQ(sequential_sum, parallel_sum); } TEST(Parallel_Operations_Std_Threads, Test_Diff) { - const int nthreads = std::thread::hardware_concurrency() * 14; - std::vector vec = getRandomVector(nthreads); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + const int nthreads = std::thread::hardware_concurrency() * 14; + std::vector vec = getRandomVector(nthreads); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } TEST(Parallel_Operations_Std_Threads, Test_Diff_2) { - const int nthreads = std::thread::hardware_concurrency() * 15; - std::vector vec = getRandomVector(nthreads); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + const int nthreads = std::thread::hardware_concurrency() * 15; + std::vector vec = getRandomVector(nthreads); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tasks/examples/test_std/ops_std.cpp b/tasks/examples/test_std/ops_std.cpp index 8f100f7d..ffabc6f7 100644 --- a/tasks/examples/test_std/ops_std.cpp +++ b/tasks/examples/test_std/ops_std.cpp @@ -1,77 +1,79 @@ // Copyright 2023 Nesterov Alexander -#include +#include "examples/test_std/ops_std.h" + +#include +#include #include #include -#include -#include -#include "examples/test_std/ops_std.h" +#include + #include "unapproved/unapproved.h" -std::vector getRandomVector(int sz) { - std::random_device dev; - std::mt19937 gen(dev()); - std::vector vec(sz); - for (int i = 0; i < sz; i++) { vec[i] = gen() % 100; } - return vec; +std::vector getRandomVector(int sz) { + std::random_device dev; + std::mt19937 gen(dev()); + std::vector vec(sz); + for (int i = 0; i < sz; i++) { + vec[i] = gen() % 100; + } + return vec; } std::mutex my_mutex; -void atomOps(std::vector vec, const std::string& ops, std::promise &&pr) { - const int sz = vec.size(); - int reduction_elem = 0; - if (ops == "+") { - for (int i = 0; i < sz; i++) { - std::lock_guard my_lock(my_mutex); - reduction_elem += vec[i]; - } - } else if (ops == "-") { - for (int i = 0; i < sz; i++) { - std::lock_guard my_lock(my_mutex); - reduction_elem -= vec[i]; - } +void atomOps(std::vector vec, const std::string &ops, + std::promise &&pr) { + const int sz = vec.size(); + int reduction_elem = 0; + if (ops == "+") { + for (int i = 0; i < sz; i++) { + std::lock_guard my_lock(my_mutex); + reduction_elem += vec[i]; } - pr.set_value(reduction_elem); + } else if (ops == "-") { + for (int i = 0; i < sz; i++) { + std::lock_guard my_lock(my_mutex); + reduction_elem -= vec[i]; + } + } + pr.set_value(reduction_elem); } +int getParallelOperations(std::vector vec, const std::string &ops) { + const int nthreads = std::thread::hardware_concurrency(); + const int delta = (vec.end() - vec.begin()) / nthreads; + std::promise *promises = new std::promise[nthreads]; + std::future *futures = new std::future[nthreads]; + std::thread *threads = new std::thread[nthreads]; -int getParallelOperations(std::vector vec, const std::string& ops) { - const int nthreads = std::thread::hardware_concurrency(); - const int delta = (vec.end() - vec.begin()) / nthreads; - - std::promise *promises = new std::promise[nthreads]; - std::future *futures = new std::future[nthreads]; - std::thread *threads = new std::thread[nthreads]; + int reduction_elem = 0; + for (int i = 0; i < nthreads; i++) { + futures[i] = promises[i].get_future(); + std::vector tmp_vec(vec.begin() + i * delta, + vec.begin() + (i + 1) * delta); + threads[i] = std::thread(atomOps, tmp_vec, ops, std::move(promises[i])); + threads[i].join(); + reduction_elem += futures[i].get(); + } - int reduction_elem = 0; - for (int i = 0; i < nthreads; i++) { - futures[i] = promises[i].get_future(); - std::vector tmp_vec( - vec.begin() + i * delta, - vec.begin() + (i + 1) * delta); - threads[i] = std::thread(atomOps, tmp_vec, ops, std::move(promises[i])); - threads[i].join(); - reduction_elem += futures[i].get(); - } - - delete []promises; - delete []futures; - delete []threads; - return reduction_elem; + delete[] promises; + delete[] futures; + delete[] threads; + return reduction_elem; } -int getSequentialOperations(std::vector vec, const std::string& ops) { - const int sz = vec.size(); - int reduction_elem = 0; - if (ops == "+") { - for (int i = 0; i < sz; i++) { - reduction_elem += vec[i]; - } - } else if (ops == "-") { - for (int i = 0; i < sz; i++) { - reduction_elem -= vec[i]; - } +int getSequentialOperations(std::vector vec, const std::string &ops) { + const int sz = vec.size(); + int reduction_elem = 0; + if (ops == "+") { + for (int i = 0; i < sz; i++) { + reduction_elem += vec[i]; + } + } else if (ops == "-") { + for (int i = 0; i < sz; i++) { + reduction_elem -= vec[i]; } - return reduction_elem; + } + return reduction_elem; } diff --git a/tasks/examples/test_std/ops_std.h b/tasks/examples/test_std/ops_std.h index 99078263..63da9073 100644 --- a/tasks/examples/test_std/ops_std.h +++ b/tasks/examples/test_std/ops_std.h @@ -2,10 +2,10 @@ #ifndef TASKS_EXAMPLES_TEST_STD_OPS_STD_H_ #define TASKS_EXAMPLES_TEST_STD_OPS_STD_H_ -#include #include +#include -std::vector getRandomVector(int sz); +std::vector getRandomVector(int sz); int getParallelOperations(std::vector vec, const std::string& ops); int getSequentialOperations(std::vector vec, const std::string& ops); diff --git a/tasks/examples/test_tbb/main.cpp b/tasks/examples/test_tbb/main.cpp index a7a645e1..a05588c6 100644 --- a/tasks/examples/test_tbb/main.cpp +++ b/tasks/examples/test_tbb/main.cpp @@ -1,44 +1,46 @@ // Copyright 2023 Nesterov Alexander #include + #include + #include "./ops_tbb.h" TEST(Parallel_Operations_TBB, Test_Sum) { - std::vector vec = getRandomVector(100); - int sequential_sum = getSequentialOperations(vec, "+"); - int parallel_sum = getParallelOperations(vec, "+"); - ASSERT_EQ(sequential_sum, parallel_sum); + std::vector vec = getRandomVector(100); + int sequential_sum = getSequentialOperations(vec, "+"); + int parallel_sum = getParallelOperations(vec, "+"); + ASSERT_EQ(sequential_sum, parallel_sum); } TEST(Parallel_Operations_TBB, Test_Diff) { - std::vector vec = getRandomVector(100); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + std::vector vec = getRandomVector(100); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } TEST(Parallel_Operations_TBB, Test_Diff_2) { - std::vector vec = getRandomVector(50); - int sequential_diff = getSequentialOperations(vec, "-"); - int parallel_diff = getParallelOperations(vec, "-"); - ASSERT_EQ(sequential_diff, parallel_diff); + std::vector vec = getRandomVector(50); + int sequential_diff = getSequentialOperations(vec, "-"); + int parallel_diff = getParallelOperations(vec, "-"); + ASSERT_EQ(sequential_diff, parallel_diff); } TEST(Parallel_Operations_TBB, Test_Mult) { - std::vector vec = getRandomVector(10); - int sequential_mult = getSequentialOperations(vec, "*"); - int parallel_mult = getParallelOperations(vec, "*"); - ASSERT_EQ(sequential_mult, parallel_mult); + std::vector vec = getRandomVector(10); + int sequential_mult = getSequentialOperations(vec, "*"); + int parallel_mult = getParallelOperations(vec, "*"); + ASSERT_EQ(sequential_mult, parallel_mult); } TEST(Parallel_Operations_TBB, Test_Mult_2) { - std::vector vec = getRandomVector(5); - int sequential_mult = getSequentialOperations(vec, "*"); - int parallel_mult = getParallelOperations(vec, "*"); - ASSERT_EQ(sequential_mult, parallel_mult); + std::vector vec = getRandomVector(5); + int sequential_mult = getSequentialOperations(vec, "*"); + int parallel_mult = getParallelOperations(vec, "*"); + ASSERT_EQ(sequential_mult, parallel_mult); } int main(int argc, char **argv) { - ::testing::InitGoogleTest(&argc, argv); - return RUN_ALL_TESTS(); + ::testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); } diff --git a/tasks/examples/test_tbb/ops_tbb.cpp b/tasks/examples/test_tbb/ops_tbb.cpp index 3542f7ed..967b408a 100644 --- a/tasks/examples/test_tbb/ops_tbb.cpp +++ b/tasks/examples/test_tbb/ops_tbb.cpp @@ -1,79 +1,83 @@ // Copyright 2023 Nesterov Alexander +#include "examples/test_tbb/ops_tbb.h" + #include -#include -#include -#include + #include #include -#include "examples/test_tbb/ops_tbb.h" +#include +#include +#include std::vector getRandomVector(int sz) { - std::random_device dev; - std::mt19937 gen(dev()); - std::vector vec(sz); - for (int i = 0; i < sz; i++) { vec[i] = gen() % 100; } - return vec; + std::random_device dev; + std::mt19937 gen(dev()); + std::vector vec(sz); + for (int i = 0; i < sz; i++) { + vec[i] = gen() % 100; + } + return vec; } struct Sum { - int value; - Sum() : value(0) {} - Sum(Sum&s, tbb::split) : value(0) {} - void operator()(const tbb::blocked_range::iterator>& r) { - value = std::accumulate(r.begin(), r.end(), value); - } - void join(const Sum& rhs) { value += rhs.value; } + int value; + Sum() : value(0) {} + Sum(Sum& s, tbb::split) : value(0) {} + void operator()(const tbb::blocked_range::iterator>& r) { + value = std::accumulate(r.begin(), r.end(), value); + } + void join(const Sum& rhs) { value += rhs.value; } }; struct Mult { - int value; - Mult() : value(1) {} - Mult(Mult&s, tbb::split) : value(1) {} - void operator()(const tbb::blocked_range::iterator>& r) { - value = std::accumulate(r.begin(), r.end(), value, std::multiplies{}); - } - void join(const Mult& rhs) { value *= rhs.value; } + int value; + Mult() : value(1) {} + Mult(Mult& s, tbb::split) : value(1) {} + void operator()(const tbb::blocked_range::iterator>& r) { + value = std::accumulate(r.begin(), r.end(), value, std::multiplies{}); + } + void join(const Mult& rhs) { value *= rhs.value; } }; int getParallelOperations(std::vector vec, const std::string& ops) { - int reduction_elem = 1; - if (ops == "+") { - Sum sum; - tbb::parallel_reduce( - tbb::blocked_range::iterator>( - vec.begin(), vec.end()), sum); - reduction_elem += sum.value; - } else if (ops == "-") { - Sum diff; - tbb::parallel_reduce( - tbb::blocked_range::iterator>( - vec.begin(), vec.end()), diff); - reduction_elem -= diff.value; - } else if (ops == "*") { - Mult mult; - tbb::parallel_reduce( - tbb::blocked_range::iterator>( - vec.begin(), vec.end()), mult); - reduction_elem *= mult.value; - } - return reduction_elem; + int reduction_elem = 1; + if (ops == "+") { + Sum sum; + tbb::parallel_reduce( + tbb::blocked_range::iterator>(vec.begin(), vec.end()), + sum); + reduction_elem += sum.value; + } else if (ops == "-") { + Sum diff; + tbb::parallel_reduce( + tbb::blocked_range::iterator>(vec.begin(), vec.end()), + diff); + reduction_elem -= diff.value; + } else if (ops == "*") { + Mult mult; + tbb::parallel_reduce( + tbb::blocked_range::iterator>(vec.begin(), vec.end()), + mult); + reduction_elem *= mult.value; + } + return reduction_elem; } int getSequentialOperations(std::vector vec, const std::string& ops) { - const int sz = vec.size(); - int reduction_elem = 1; - if (ops == "+") { - for (int i = 0; i < sz; i++) { - reduction_elem += vec[i]; - } - } else if (ops == "-") { - for (int i = 0; i < sz; i++) { - reduction_elem -= vec[i]; - } - } else if (ops == "*") { - for (int i = 0; i < sz; i++) { - reduction_elem *= vec[i]; - } + const int sz = vec.size(); + int reduction_elem = 1; + if (ops == "+") { + for (int i = 0; i < sz; i++) { + reduction_elem += vec[i]; + } + } else if (ops == "-") { + for (int i = 0; i < sz; i++) { + reduction_elem -= vec[i]; + } + } else if (ops == "*") { + for (int i = 0; i < sz; i++) { + reduction_elem *= vec[i]; } - return reduction_elem; + } + return reduction_elem; } diff --git a/tasks/examples/test_tbb/ops_tbb.h b/tasks/examples/test_tbb/ops_tbb.h index d78906f6..0047d3a3 100644 --- a/tasks/examples/test_tbb/ops_tbb.h +++ b/tasks/examples/test_tbb/ops_tbb.h @@ -2,8 +2,8 @@ #ifndef TASKS_EXAMPLES_TEST_TBB_OPS_TBB_H_ #define TASKS_EXAMPLES_TEST_TBB_OPS_TBB_H_ -#include #include +#include std::vector getRandomVector(int sz); int getParallelOperations(std::vector vec, const std::string& ops);