From 14b75361cd6fa2642a475d352d876e82ed8e7973 Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Fri, 20 Feb 2026 13:20:55 +0000 Subject: [PATCH 1/7] initial --- .../all/include/ops_all.hpp | 22 +++++ .../all/report.md | 0 .../all/src/ops_all.cpp | 85 ++++++++++++++++ .../common/include/common.hpp | 15 +++ .../data/pic.ppm | Bin 0 -> 23 bytes .../info.json | 9 ++ .../omp/include/ops_omp.hpp | 22 +++++ .../omp/report.md | 0 .../omp/src/ops_omp.cpp | 54 ++++++++++ .../report.md | 0 .../seq/include/ops_seq.hpp | 22 +++++ .../seq/report.md | 0 .../seq/src/ops_seq.cpp | 60 ++++++++++++ .../settings.json | 10 ++ .../stl/include/ops_stl.hpp | 22 +++++ .../stl/report.md | 0 .../stl/src/ops_stl.cpp | 58 +++++++++++ .../tbb/include/ops_tbb.hpp | 22 +++++ .../tbb/report.md | 0 .../tbb/src/ops_tbb.cpp | 56 +++++++++++ .../tests/functional/main.cpp | 92 ++++++++++++++++++ .../tests/performance/main.cpp | 48 +++++++++ 22 files changed, 597 insertions(+) create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/data/pic.ppm create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/settings.json create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/report.md create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp create mode 100644 tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp new file mode 100644 index 00000000..78afb65a --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIBitwiseSortDoubleEOBatcherMergeALL : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kALL; + } + explicit DorofeevIBitwiseSortDoubleEOBatcherMergeALL(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp new file mode 100644 index 00000000..8e7a449f --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp @@ -0,0 +1,85 @@ +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" + +#include + +#include +#include +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "oneapi/tbb/parallel_for.h" +#include "util/include/util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +DorofeevIBitwiseSortDoubleEOBatcherMergeALL::DorofeevIBitwiseSortDoubleEOBatcherMergeALL(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; + GetOutput() = 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::ValidationImpl() { + return (GetInput() > 0) && (GetOutput() == 0); +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PreProcessingImpl() { + GetOutput() = 2 * GetInput(); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::RunImpl() { + for (InType i = 0; i < GetInput(); i++) { + for (InType j = 0; j < GetInput(); j++) { + for (InType k = 0; k < GetInput(); k++) { + std::vector tmp(i + j + k, 1); + GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); + GetOutput() -= i + j + k; + } + } + } + + const int num_threads = ppc::util::GetNumThreads(); + { + GetOutput() *= num_threads; + + int rank = -1; + MPI_Comm_rank(MPI_COMM_WORLD, &rank); + if (rank == 0) { + std::atomic counter(0); +#pragma omp parallel default(none) shared(counter) num_threads(ppc::util::GetNumThreads()) + counter++; + + GetOutput() /= counter; + } else { + GetOutput() /= num_threads; + } + } + + { + GetOutput() *= num_threads; + std::vector threads(num_threads); + std::atomic counter(0); + for (int i = 0; i < num_threads; i++) { + threads[i] = std::thread([&]() { counter++; }); + threads[i].join(); + } + GetOutput() /= counter; + } + + { + GetOutput() *= num_threads; + std::atomic counter(0); + tbb::parallel_for(0, ppc::util::GetNumThreads(), [&](int /*i*/) { counter++; }); + GetOutput() /= counter; + } + MPI_Barrier(MPI_COMM_WORLD); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PostProcessingImpl() { + GetOutput() -= GetInput(); + return GetOutput() > 0; +} + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp new file mode 100644 index 00000000..103845de --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp @@ -0,0 +1,15 @@ +#pragma once + +#include +#include + +#include "task/include/task.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +using InType = int; +using OutType = int; +using TestType = std::tuple; +using BaseTask = ppc::task::Task; + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/data/pic.ppm b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/data/pic.ppm new file mode 100644 index 0000000000000000000000000000000000000000..637624238c89d914613ed301968bffbf462bc110 GIT binary patch literal 23 bcmWGA<1$h(;xaNd<@(RSzyQYo|NjR7KDY +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "util/include/util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::DorofeevIBitwiseSortDoubleEOBatcherMergeOMP(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; + GetOutput() = 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::ValidationImpl() { + return (GetInput() > 0) && (GetOutput() == 0); +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PreProcessingImpl() { + GetOutput() = 2 * GetInput(); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::RunImpl() { + for (InType i = 0; i < GetInput(); i++) { + for (InType j = 0; j < GetInput(); j++) { + for (InType k = 0; k < GetInput(); k++) { + std::vector tmp(i + j + k, 1); + GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); + GetOutput() -= i + j + k; + } + } + } + + const int num_threads = ppc::util::GetNumThreads(); + GetOutput() *= num_threads; + + std::atomic counter(0); +#pragma omp parallel default(none) shared(counter) num_threads(ppc::util::GetNumThreads()) + counter++; + + GetOutput() /= counter; + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PostProcessingImpl() { + GetOutput() -= GetInput(); + return GetOutput() > 0; +} + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp new file mode 100644 index 00000000..2cdc7e2d --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kSEQ; + } + explicit DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp new file mode 100644 index 00000000..3f6fa2a0 --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp @@ -0,0 +1,60 @@ +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" + +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "util/include/util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; + GetOutput() = 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::ValidationImpl() { + return (GetInput() > 0) && (GetOutput() == 0); +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PreProcessingImpl() { + GetOutput() = 2 * GetInput(); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { + if (GetInput() == 0) { + return false; + } + + for (InType i = 0; i < GetInput(); i++) { + for (InType j = 0; j < GetInput(); j++) { + for (InType k = 0; k < GetInput(); k++) { + std::vector tmp(i + j + k, 1); + GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); + GetOutput() -= i + j + k; + } + } + } + + const int num_threads = ppc::util::GetNumThreads(); + GetOutput() *= num_threads; + + int counter = 0; + for (int i = 0; i < num_threads; i++) { + counter++; + } + + if (counter != 0) { + GetOutput() /= counter; + } + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PostProcessingImpl() { + GetOutput() -= GetInput(); + return GetOutput() > 0; +} + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/settings.json b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/settings.json new file mode 100644 index 00000000..0be0208f --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/settings.json @@ -0,0 +1,10 @@ +{ + "tasks": { + "all": "enabled", + "omp": "enabled", + "seq": "enabled", + "stl": "enabled", + "tbb": "enabled" + }, + "tasks_type": "threads" +} diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp new file mode 100644 index 00000000..0782ac84 --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIBitwiseSortDoubleEOBatcherMergeSTL : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kSTL; + } + explicit DorofeevIBitwiseSortDoubleEOBatcherMergeSTL(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp new file mode 100644 index 00000000..c1ac40b7 --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp @@ -0,0 +1,58 @@ +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" + +#include +#include +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "util/include/util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::DorofeevIBitwiseSortDoubleEOBatcherMergeSTL(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; + GetOutput() = 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::ValidationImpl() { + return (GetInput() > 0) && (GetOutput() == 0); +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PreProcessingImpl() { + GetOutput() = 2 * GetInput(); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::RunImpl() { + for (InType i = 0; i < GetInput(); i++) { + for (InType j = 0; j < GetInput(); j++) { + for (InType k = 0; k < GetInput(); k++) { + std::vector tmp(i + j + k, 1); + GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); + GetOutput() -= i + j + k; + } + } + } + + const int num_threads = ppc::util::GetNumThreads(); + std::vector threads(num_threads); + GetOutput() *= num_threads; + + std::atomic counter(0); + for (int i = 0; i < num_threads; i++) { + threads[i] = std::thread([&]() { counter++; }); + threads[i].join(); + } + + GetOutput() /= counter; + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PostProcessingImpl() { + GetOutput() -= GetInput(); + return GetOutput() > 0; +} + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp new file mode 100644 index 00000000..9e95dbdc --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp @@ -0,0 +1,22 @@ +#pragma once + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIBitwiseSortDoubleEOBatcherMergeTBB : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kTBB; + } + explicit DorofeevIBitwiseSortDoubleEOBatcherMergeTBB(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; +}; + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp new file mode 100644 index 00000000..9af8ee85 --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp @@ -0,0 +1,56 @@ +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" + +#include + +#include +#include +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "oneapi/tbb/parallel_for.h" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::DorofeevIBitwiseSortDoubleEOBatcherMergeTBB(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; + GetOutput() = 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::ValidationImpl() { + return (GetInput() > 0) && (GetOutput() == 0); +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PreProcessingImpl() { + GetOutput() = 2 * GetInput(); + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::RunImpl() { + for (InType i = 0; i < GetInput(); i++) { + for (InType j = 0; j < GetInput(); j++) { + for (InType k = 0; k < GetInput(); k++) { + std::vector tmp(i + j + k, 1); + GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); + GetOutput() -= i + j + k; + } + } + } + + const int num_threads = ppc::util::GetNumThreads(); + GetOutput() *= num_threads; + + std::atomic counter(0); + tbb::parallel_for(0, ppc::util::GetNumThreads(), [&](int /*i*/) { counter++; }); + + GetOutput() /= counter; + return GetOutput() > 0; +} + +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PostProcessingImpl() { + GetOutput() -= GetInput(); + return GetOutput() > 0; +} + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp new file mode 100644 index 00000000..f56d070b --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp @@ -0,0 +1,92 @@ +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" +#include "util/include/func_test_util.hpp" +#include "util/include/util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests { + public: + static std::string PrintTestParam(const TestType &test_param) { + return std::to_string(std::get<0>(test_param)) + "_" + std::get<1>(test_param); + } + + protected: + void SetUp() override { + int width = -1; + int height = -1; + int channels = -1; + std::vector img; + // Read image in RGB to ensure consistent channel count + { + std::string abs_path = ppc::util::GetAbsoluteTaskPath(std::string("dorofeev_i_bitwise_sort_double_eo_batcher_merge"), "pic.ppm"); + auto *data = stbi_load(abs_path.c_str(), &width, &height, &channels, STBI_rgb); + if (data == nullptr) { + throw std::runtime_error("Failed to load image: " + std::string(stbi_failure_reason())); + } + channels = STBI_rgb; + img = std::vector(data, data + (static_cast(width * height * channels))); + stbi_image_free(data); + if (std::cmp_not_equal(width, height)) { + throw std::runtime_error("width != height: "); + } + } + + TestType params = std::get(ppc::util::GTestParamIndex::kTestParams)>(GetParam()); + input_data_ = width - height + std::min(std::accumulate(img.begin(), img.end(), 0), channels); + } + + bool CheckTestOutputData(OutType &output_data) final { + return (input_data_ == output_data); + } + + InType GetTestInputData() final { + return input_data_; + } + + private: + InType input_data_ = 0; +}; + +namespace { + +TEST_P(DorofeevIRunFuncTestsThreads, MatmulFromPic) { + ExecuteTest(GetParam()); +} + +const std::array kTestParam = {std::make_tuple(3, "3"), std::make_tuple(5, "5"), std::make_tuple(7, "7")}; + +const auto kTestTasksList = + std::tuple_cat(ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), + ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), + ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), + ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), + ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads)); + +const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList); + +const auto kPerfTestName = DorofeevIRunFuncTestsThreads::PrintFuncTestName; + +INSTANTIATE_TEST_SUITE_P(PicMatrixTests, DorofeevIRunFuncTestsThreads, kGtestValues, kPerfTestName); + +} // namespace + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp new file mode 100644 index 00000000..1901e7fa --- /dev/null +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp @@ -0,0 +1,48 @@ +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" +#include "util/include/perf_test_util.hpp" + +namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { + +class DorofeevIRunPerfTestThreads : public ppc::util::BaseRunPerfTests { + const int kCount_ = 200; + InType input_data_{}; + + void SetUp() override { + input_data_ = kCount_; + } + + bool CheckTestOutputData(OutType &output_data) final { + return input_data_ == output_data; + } + + InType GetTestInputData() final { + return input_data_; + } +}; + +TEST_P(DorofeevIRunPerfTestThreads, RunPerfModes) { + ExecuteTest(GetParam()); +} + +namespace { + +const auto kAllPerfTasks = + ppc::util::MakeAllPerfTasks("dorofeev_i_bitwise_sort_double_eo_batcher_merge"); + +const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); + +const auto kPerfTestName = DorofeevIRunPerfTestThreads::CustomPerfTestName; + +INSTANTIATE_TEST_SUITE_P(RunModeTests, DorofeevIRunPerfTestThreads, kGtestValues, kPerfTestName); + +} // namespace + +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge From e3a6355f4af1753e5c5fd0e39248813608366678 Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Fri, 20 Feb 2026 14:05:58 +0000 Subject: [PATCH 2/7] seq_complete --- .../all/src/ops_all.cpp | 80 +--------- .../common/include/common.hpp | 9 +- .../info.json | 8 +- .../omp/src/ops_omp.cpp | 49 +----- .../seq/include/ops_seq.hpp | 7 +- .../seq/src/ops_seq.cpp | 140 ++++++++++++++---- .../stl/src/ops_stl.cpp | 53 +------ .../tbb/src/ops_tbb.cpp | 51 +------ .../tests/functional/main.cpp | 74 ++++----- .../tests/performance/main.cpp | 46 +++--- 10 files changed, 213 insertions(+), 304 deletions(-) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp index 8e7a449f..93fdf3a3 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp @@ -1,85 +1,15 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" -#include - -#include -#include -#include -#include - -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "oneapi/tbb/parallel_for.h" -#include "util/include/util.hpp" - namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { DorofeevIBitwiseSortDoubleEOBatcherMergeALL::DorofeevIBitwiseSortDoubleEOBatcherMergeALL(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; - GetOutput() = 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::ValidationImpl() { - return (GetInput() > 0) && (GetOutput() == 0); -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PreProcessingImpl() { - GetOutput() = 2 * GetInput(); - return GetOutput() > 0; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::RunImpl() { - for (InType i = 0; i < GetInput(); i++) { - for (InType j = 0; j < GetInput(); j++) { - for (InType k = 0; k < GetInput(); k++) { - std::vector tmp(i + j + k, 1); - GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); - GetOutput() -= i + j + k; - } - } - } - - const int num_threads = ppc::util::GetNumThreads(); - { - GetOutput() *= num_threads; - - int rank = -1; - MPI_Comm_rank(MPI_COMM_WORLD, &rank); - if (rank == 0) { - std::atomic counter(0); -#pragma omp parallel default(none) shared(counter) num_threads(ppc::util::GetNumThreads()) - counter++; - - GetOutput() /= counter; - } else { - GetOutput() /= num_threads; - } - } - - { - GetOutput() *= num_threads; - std::vector threads(num_threads); - std::atomic counter(0); - for (int i = 0; i < num_threads; i++) { - threads[i] = std::thread([&]() { counter++; }); - threads[i].join(); - } - GetOutput() /= counter; - } - - { - GetOutput() *= num_threads; - std::atomic counter(0); - tbb::parallel_for(0, ppc::util::GetNumThreads(), [&](int /*i*/) { counter++; }); - GetOutput() /= counter; - } - MPI_Barrier(MPI_COMM_WORLD); - return GetOutput() > 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PostProcessingImpl() { - GetOutput() -= GetInput(); - return GetOutput() > 0; -} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::ValidationImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PreProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::RunImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PostProcessingImpl() { return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp index 103845de..43c0d271 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp @@ -2,14 +2,17 @@ #include #include +#include #include "task/include/task.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { -using InType = int; -using OutType = int; +// Изменили int на std::vector +using InType = std::vector; +using OutType = std::vector; + using TestType = std::tuple; using BaseTask = ppc::task::Task; -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json index 07492a20..ed1c2a00 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "first_name_t", - "group_number": "2222222_t", - "last_name": "last_name_t", - "middle_name": "middle_name_t", + "first_name": "Иван", + "group_number": "3823Б1ФИ1", + "last_name": "Дорофеев", + "middle_name": "Денисович", "task_number": "1" } } diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp index 34322c3f..ca3c6d90 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp @@ -1,54 +1,15 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" -#include -#include -#include - -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "util/include/util.hpp" - namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::DorofeevIBitwiseSortDoubleEOBatcherMergeOMP(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; - GetOutput() = 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::ValidationImpl() { - return (GetInput() > 0) && (GetOutput() == 0); -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PreProcessingImpl() { - GetOutput() = 2 * GetInput(); - return GetOutput() > 0; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::RunImpl() { - for (InType i = 0; i < GetInput(); i++) { - for (InType j = 0; j < GetInput(); j++) { - for (InType k = 0; k < GetInput(); k++) { - std::vector tmp(i + j + k, 1); - GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); - GetOutput() -= i + j + k; - } - } - } - - const int num_threads = ppc::util::GetNumThreads(); - GetOutput() *= num_threads; - - std::atomic counter(0); -#pragma omp parallel default(none) shared(counter) num_threads(ppc::util::GetNumThreads()) - counter++; - - GetOutput() /= counter; - return GetOutput() > 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PostProcessingImpl() { - GetOutput() -= GetInput(); - return GetOutput() > 0; -} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::ValidationImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PreProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::RunImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PostProcessingImpl() { return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp index 2cdc7e2d..788e897a 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp @@ -1,5 +1,7 @@ #pragma once +#include + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" #include "task/include/task.hpp" @@ -17,6 +19,9 @@ class DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ : public BaseTask { bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; + + // Локальный вектор для сортировки + std::vector local_data_; }; -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp index 3f6fa2a0..633b98f6 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp @@ -1,60 +1,138 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" -#include +#include +#include +#include #include -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "util/include/util.hpp" - namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { +namespace { + +// Преобразование double в uint64_t с сохранением порядка сортировки +uint64_t DoubleToUint(double d) { + uint64_t u; + std::memcpy(&u, &d, sizeof(double)); + if ((u & 0x8000000000000000ULL) != 0) { + u = ~u; // Инвертируем все биты для отрицательных + } else { + u |= 0x8000000000000000ULL; // Инвертируем только знаковый бит для положительных + } + return u; +} + +// Обратное преобразование +double UintToDouble(uint64_t u) { + if ((u & 0x8000000000000000ULL) != 0) { + u &= ~0x8000000000000000ULL; + } else { + u = ~u; + } + double d; + std::memcpy(&d, &u, sizeof(double)); + return d; +} + +// Поразрядная сортировка подмассива +void RadixSortDouble(std::vector& arr) { + if (arr.empty()) return; + + std::vector uarr(arr.size()); + for (size_t i = 0; i < arr.size(); ++i) { + uarr[i] = DoubleToUint(arr[i]); + } + + std::vector temp(uarr.size()); + for (int byte = 0; byte < 8; ++byte) { + int count[256] = {0}; + for (uint64_t val : uarr) { + count[(val >> (byte * 8)) & 0xFF]++; + } + for (int i = 1; i < 256; ++i) { + count[i] += count[i - 1]; + } + for (int i = static_cast(uarr.size()) - 1; i >= 0; --i) { + temp[--count[(uarr[i] >> (byte * 8)) & 0xFF]] = uarr[i]; + } + uarr = temp; + } + + for (size_t i = 0; i < arr.size(); ++i) { + arr[i] = UintToDouble(uarr[i]); + } +} + +// Четно-нечетное слияние Бэтчера +void OddEvenMerge(std::vector& arr, int l, int n, int step) { + int m = step * 2; + if (m < n) { + OddEvenMerge(arr, l, n, m); + OddEvenMerge(arr, l + step, n, m); + for (int i = l + step; i + step < l + n; i += m) { + if (arr[i] > arr[i + step]) { + std::swap(arr[i], arr[i + step]); + } + } + } else { + if (l + step < l + n && arr[l] > arr[l + step]) { + std::swap(arr[l], arr[l + step]); + } + } +} + +} // namespace + DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; - GetOutput() = 0; } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::ValidationImpl() { - return (GetInput() > 0) && (GetOutput() == 0); + return true; // Сортировка пустого массива тоже валидна } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PreProcessingImpl() { - GetOutput() = 2 * GetInput(); - return GetOutput() > 0; + local_data_ = GetInput(); + return true; } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { - if (GetInput() == 0) { - return false; - } + if (local_data_.empty()) return true; - for (InType i = 0; i < GetInput(); i++) { - for (InType j = 0; j < GetInput(); j++) { - for (InType k = 0; k < GetInput(); k++) { - std::vector tmp(i + j + k, 1); - GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); - GetOutput() -= i + j + k; - } - } + size_t original_size = local_data_.size(); + + // Добиваем до ближайшей степени двойки + size_t pow2 = 1; + while (pow2 < original_size) pow2 *= 2; + + if (pow2 > original_size) { + local_data_.resize(pow2, std::numeric_limits::max()); } - const int num_threads = ppc::util::GetNumThreads(); - GetOutput() *= num_threads; + // Для SEQ версии бьем на 2 части, сортируем их и сливаем Бэтчером (имитация параллелизма) + size_t mid = pow2 / 2; + std::vector left(local_data_.begin(), local_data_.begin() + mid); + std::vector right(local_data_.begin() + mid, local_data_.end()); - int counter = 0; - for (int i = 0; i < num_threads; i++) { - counter++; - } + RadixSortDouble(left); + RadixSortDouble(right); + + std::copy(left.begin(), left.end(), local_data_.begin()); + std::copy(right.begin(), right.end(), local_data_.begin() + mid); - if (counter != 0) { - GetOutput() /= counter; + OddEvenMerge(local_data_, 0, pow2, 1); + + // Отрезаем фиктивные элементы + if (pow2 > original_size) { + local_data_.resize(original_size); } - return GetOutput() > 0; + + return true; } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PostProcessingImpl() { - GetOutput() -= GetInput(); - return GetOutput() > 0; + GetOutput() = local_data_; + return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp index c1ac40b7..8cb4bf7e 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp @@ -1,58 +1,15 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" -#include -#include -#include -#include - -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "util/include/util.hpp" - namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::DorofeevIBitwiseSortDoubleEOBatcherMergeSTL(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; - GetOutput() = 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::ValidationImpl() { - return (GetInput() > 0) && (GetOutput() == 0); -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PreProcessingImpl() { - GetOutput() = 2 * GetInput(); - return GetOutput() > 0; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::RunImpl() { - for (InType i = 0; i < GetInput(); i++) { - for (InType j = 0; j < GetInput(); j++) { - for (InType k = 0; k < GetInput(); k++) { - std::vector tmp(i + j + k, 1); - GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); - GetOutput() -= i + j + k; - } - } - } - - const int num_threads = ppc::util::GetNumThreads(); - std::vector threads(num_threads); - GetOutput() *= num_threads; - - std::atomic counter(0); - for (int i = 0; i < num_threads; i++) { - threads[i] = std::thread([&]() { counter++; }); - threads[i].join(); - } - - GetOutput() /= counter; - return GetOutput() > 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PostProcessingImpl() { - GetOutput() -= GetInput(); - return GetOutput() > 0; -} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::ValidationImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PreProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::RunImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PostProcessingImpl() { return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp index 9af8ee85..2d95c27f 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp @@ -1,56 +1,15 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" -#include - -#include -#include -#include -#include - -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "oneapi/tbb/parallel_for.h" - namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::DorofeevIBitwiseSortDoubleEOBatcherMergeTBB(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; - GetOutput() = 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::ValidationImpl() { - return (GetInput() > 0) && (GetOutput() == 0); -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PreProcessingImpl() { - GetOutput() = 2 * GetInput(); - return GetOutput() > 0; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::RunImpl() { - for (InType i = 0; i < GetInput(); i++) { - for (InType j = 0; j < GetInput(); j++) { - for (InType k = 0; k < GetInput(); k++) { - std::vector tmp(i + j + k, 1); - GetOutput() += std::accumulate(tmp.begin(), tmp.end(), 0); - GetOutput() -= i + j + k; - } - } - } - - const int num_threads = ppc::util::GetNumThreads(); - GetOutput() *= num_threads; - - std::atomic counter(0); - tbb::parallel_for(0, ppc::util::GetNumThreads(), [&](int /*i*/) { counter++; }); - - GetOutput() /= counter; - return GetOutput() > 0; -} - -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PostProcessingImpl() { - GetOutput() -= GetInput(); - return GetOutput() > 0; -} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::ValidationImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PreProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::RunImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PostProcessingImpl() { return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp index f56d070b..41c92b6c 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp @@ -1,12 +1,9 @@ #include -#include #include #include #include -#include -#include -#include +#include #include #include #include @@ -31,31 +28,29 @@ class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests img; - // Read image in RGB to ensure consistent channel count - { - std::string abs_path = ppc::util::GetAbsoluteTaskPath(std::string("dorofeev_i_bitwise_sort_double_eo_batcher_merge"), "pic.ppm"); - auto *data = stbi_load(abs_path.c_str(), &width, &height, &channels, STBI_rgb); - if (data == nullptr) { - throw std::runtime_error("Failed to load image: " + std::string(stbi_failure_reason())); - } - channels = STBI_rgb; - img = std::vector(data, data + (static_cast(width * height * channels))); - stbi_image_free(data); - if (std::cmp_not_equal(width, height)) { - throw std::runtime_error("width != height: "); - } - } - + // 1. Достаем НАШ кортеж параметров из обертки фреймворка TestType params = std::get(ppc::util::GTestParamIndex::kTestParams)>(GetParam()); - input_data_ = width - height + std::min(std::accumulate(img.begin(), img.end(), 0), channels); + + // 2. И уже из нашего кортежа берем размер массива (нулевой элемент) + int size = std::get<0>(params); + + // Настраиваем генератор случайных чисел + std::mt19937 gen(42); // Фиксированный сид для стабильности тестов + std::uniform_real_distribution dist(-1000.0, 1000.0); + + input_data_.resize(size); + for (int i = 0; i < size; ++i) { + input_data_[i] = dist(gen); + } } bool CheckTestOutputData(OutType &output_data) final { - return (input_data_ == output_data); + // Создаем эталонный вектор и сортируем его стандартным методом + std::vector expected = input_data_; + std::sort(expected.begin(), expected.end()); + + // Сравниваем результат твоей таски с эталоном + return output_data == expected; } InType GetTestInputData() final { @@ -63,30 +58,39 @@ class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests kTestParam = {std::make_tuple(3, "3"), std::make_tuple(5, "5"), std::make_tuple(7, "7")}; +// Задаем параметры: размер массива и строковое описание для логов +const std::array kTestParam = { + std::make_tuple(10, "Small_Array"), + std::make_tuple(128, "Power_Of_Two"), + std::make_tuple(137, "Odd_Size"), + std::make_tuple(1000, "Large_Array") +}; + +const auto kTaskName = PPC_SETTINGS_dorofeev_i_bitwise_sort_double_eo_batcher_merge; +// Собираем все реализации (ALL, OMP, SEQ, STL, TBB) в один тестовый набор const auto kTestTasksList = - std::tuple_cat(ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), - ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), - ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), - ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads), - ppc::util::AddFuncTask(kTestParam, PPC_SETTINGS_example_threads)); + std::tuple_cat(/*ppc::util::AddFuncTask(kTestParam, kTaskName), + ppc::util::AddFuncTask(kTestParam, kTaskName),*/ + ppc::util::AddFuncTask(kTestParam, kTaskName) + /*ppc::util::AddFuncTask(kTestParam, kTaskName), + ppc::util::AddFuncTask(kTestParam, kTaskName)*/); const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList); const auto kPerfTestName = DorofeevIRunFuncTestsThreads::PrintFuncTestName; -INSTANTIATE_TEST_SUITE_P(PicMatrixTests, DorofeevIRunFuncTestsThreads, kGtestValues, kPerfTestName); +INSTANTIATE_TEST_SUITE_P(SortTests, DorofeevIRunFuncTestsThreads, kGtestValues, kPerfTestName); } // namespace -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp index 1901e7fa..f1c97b8d 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp @@ -1,25 +1,32 @@ #include -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" +#include +#include +#include + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" #include "util/include/perf_test_util.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { -class DorofeevIRunPerfTestThreads : public ppc::util::BaseRunPerfTests { - const int kCount_ = 200; +class DorofeevIPerfTestThreads : public ppc::util::BaseRunPerfTests { + protected: + const int kCount_ = 100000; // Большой массив для проверки производительности InType input_data_{}; void SetUp() override { - input_data_ = kCount_; + std::mt19937 gen(42); + std::uniform_real_distribution dist(-5000.0, 5000.0); + + input_data_.resize(kCount_); + for (auto& val : input_data_) { + val = dist(gen); + } } bool CheckTestOutputData(OutType &output_data) final { - return input_data_ == output_data; + // В перф тестах достаточно проверить, что массив просто отсортирован + return std::is_sorted(output_data.begin(), output_data.end()); } InType GetTestInputData() final { @@ -27,22 +34,27 @@ class DorofeevIRunPerfTestThreads : public ppc::util::BaseRunPerfTests("dorofeev_i_bitwise_sort_double_eo_batcher_merge"); + ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_dorofeev_i_bitwise_sort_double_eo_batcher_merge); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); -const auto kPerfTestName = DorofeevIRunPerfTestThreads::CustomPerfTestName; +const auto kPerfTestName = DorofeevIPerfTestThreads::CustomPerfTestName; -INSTANTIATE_TEST_SUITE_P(RunModeTests, DorofeevIRunPerfTestThreads, kGtestValues, kPerfTestName); +INSTANTIATE_TEST_SUITE_P(RunModeTests, DorofeevIPerfTestThreads, kGtestValues, kPerfTestName); } // namespace -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file From 7ec975f69a05ff1b315760c245cd2a7ed5351edd Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Fri, 20 Feb 2026 14:40:11 +0000 Subject: [PATCH 3/7] clang --- .../all/src/ops_all.cpp | 19 ++++++--- .../common/include/common.hpp | 2 +- .../omp/src/ops_omp.cpp | 19 ++++++--- .../seq/include/ops_seq.hpp | 2 +- .../seq/src/ops_seq.cpp | 42 ++++++++++++------- .../stl/src/ops_stl.cpp | 19 ++++++--- .../tbb/src/ops_tbb.cpp | 19 ++++++--- .../tests/functional/main.cpp | 23 ++++------ .../tests/performance/main.cpp | 35 ++++++++-------- 9 files changed, 108 insertions(+), 72 deletions(-) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp index 93fdf3a3..1ab6a7be 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { @@ -7,9 +8,17 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeALL::DorofeevIBitwiseSortDoubleEOBatcher GetInput() = in; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::ValidationImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PreProcessingImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::RunImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PostProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::ValidationImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PreProcessingImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::RunImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeALL::PostProcessingImpl() { + return true; +} -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp index 43c0d271..1af70c7e 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp @@ -15,4 +15,4 @@ using OutType = std::vector; using TestType = std::tuple; using BaseTask = ppc::task::Task; -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp index ca3c6d90..3110986d 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { @@ -7,9 +8,17 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::DorofeevIBitwiseSortDoubleEOBatcher GetInput() = in; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::ValidationImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PreProcessingImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::RunImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PostProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::ValidationImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PreProcessingImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::RunImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeOMP::PostProcessingImpl() { + return true; +} -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp index 788e897a..e2983fb1 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp @@ -24,4 +24,4 @@ class DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ : public BaseTask { std::vector local_data_; }; -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp index 633b98f6..4d23bc71 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp @@ -1,6 +1,10 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" +#include + +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" #include +#include #include #include #include @@ -11,12 +15,12 @@ namespace { // Преобразование double в uint64_t с сохранением порядка сортировки uint64_t DoubleToUint(double d) { - uint64_t u; + uint64_t u = 0; std::memcpy(&u, &d, sizeof(double)); if ((u & 0x8000000000000000ULL) != 0) { - u = ~u; // Инвертируем все биты для отрицательных + u = ~u; // Инвертируем все биты для отрицательных } else { - u |= 0x8000000000000000ULL; // Инвертируем только знаковый бит для положительных + u |= 0x8000000000000000ULL; // Инвертируем только знаковый бит для положительных } return u; } @@ -28,15 +32,17 @@ double UintToDouble(uint64_t u) { } else { u = ~u; } - double d; + double d = NAN; std::memcpy(&d, &u, sizeof(double)); return d; } // Поразрядная сортировка подмассива -void RadixSortDouble(std::vector& arr) { - if (arr.empty()) return; - +void RadixSortDouble(std::vector &arr) { + if (arr.empty()) { + return; + } + std::vector uarr(arr.size()); for (size_t i = 0; i < arr.size(); ++i) { uarr[i] = DoubleToUint(arr[i]); @@ -63,7 +69,7 @@ void RadixSortDouble(std::vector& arr) { } // Четно-нечетное слияние Бэтчера -void OddEvenMerge(std::vector& arr, int l, int n, int step) { +void OddEvenMerge(std::vector &arr, int l, int n, int step) { int m = step * 2; if (m < n) { OddEvenMerge(arr, l, n, m); @@ -88,7 +94,7 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::DorofeevIBitwiseSortDoubleEOBatcher } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::ValidationImpl() { - return true; // Сортировка пустого массива тоже валидна + return true; // Сортировка пустого массива тоже валидна } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PreProcessingImpl() { @@ -97,14 +103,18 @@ bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PreProcessingImpl() { } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { - if (local_data_.empty()) return true; + if (local_data_.empty()) { + return true; + } size_t original_size = local_data_.size(); - + // Добиваем до ближайшей степени двойки size_t pow2 = 1; - while (pow2 < original_size) pow2 *= 2; - + while (pow2 < original_size) { + pow2 *= 2; + } + if (pow2 > original_size) { local_data_.resize(pow2, std::numeric_limits::max()); } @@ -117,8 +127,8 @@ bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { RadixSortDouble(left); RadixSortDouble(right); - std::copy(left.begin(), left.end(), local_data_.begin()); - std::copy(right.begin(), right.end(), local_data_.begin() + mid); + std::ranges::copy(left, local_data_.begin()); + std::ranges::copy(right, local_data_.begin() + mid); OddEvenMerge(local_data_, 0, pow2, 1); @@ -135,4 +145,4 @@ bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PostProcessingImpl() { return true; } -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp index 8cb4bf7e..6e6974ca 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { @@ -7,9 +8,17 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::DorofeevIBitwiseSortDoubleEOBatcher GetInput() = in; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::ValidationImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PreProcessingImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::RunImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PostProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::ValidationImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PreProcessingImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::RunImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeSTL::PostProcessingImpl() { + return true; +} -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp index 2d95c27f..b4edcc1d 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { @@ -7,9 +8,17 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::DorofeevIBitwiseSortDoubleEOBatcher GetInput() = in; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::ValidationImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PreProcessingImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::RunImpl() { return true; } -bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PostProcessingImpl() { return true; } +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::ValidationImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PreProcessingImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::RunImpl() { + return true; +} +bool DorofeevIBitwiseSortDoubleEOBatcherMergeTBB::PostProcessingImpl() { + return true; +} -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp index 41c92b6c..bfa8b116 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp @@ -6,15 +6,10 @@ #include #include #include -#include #include -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" #include "util/include/func_test_util.hpp" #include "util/include/util.hpp" @@ -30,12 +25,12 @@ class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests(ppc::util::GTestParamIndex::kTestParams)>(GetParam()); - + // 2. И уже из нашего кортежа берем размер массива (нулевой элемент) int size = std::get<0>(params); // Настраиваем генератор случайных чисел - std::mt19937 gen(42); // Фиксированный сид для стабильности тестов + std::mt19937 gen(42); // Фиксированный сид для стабильности тестов std::uniform_real_distribution dist(-1000.0, 1000.0); input_data_.resize(size); @@ -47,8 +42,8 @@ class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests expected = input_data_; - std::sort(expected.begin(), expected.end()); - + std::ranges::sort(expected); + // Сравниваем результат твоей таски с эталоном return output_data == expected; } @@ -68,12 +63,8 @@ TEST_P(DorofeevIRunFuncTestsThreads, TestSort) { } // Задаем параметры: размер массива и строковое описание для логов -const std::array kTestParam = { - std::make_tuple(10, "Small_Array"), - std::make_tuple(128, "Power_Of_Two"), - std::make_tuple(137, "Odd_Size"), - std::make_tuple(1000, "Large_Array") -}; +const std::array kTestParam = {std::make_tuple(10, "Small_Array"), std::make_tuple(128, "Power_Of_Two"), + std::make_tuple(137, "Odd_Size"), std::make_tuple(1000, "Large_Array")}; const auto kTaskName = PPC_SETTINGS_dorofeev_i_bitwise_sort_double_eo_batcher_merge; @@ -93,4 +84,4 @@ INSTANTIATE_TEST_SUITE_P(SortTests, DorofeevIRunFuncTestsThreads, kGtestValues, } // namespace -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp index f1c97b8d..53dd4125 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp @@ -2,35 +2,35 @@ #include #include -#include +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" #include "util/include/perf_test_util.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { class DorofeevIPerfTestThreads : public ppc::util::BaseRunPerfTests { - protected: - const int kCount_ = 100000; // Большой массив для проверки производительности - InType input_data_{}; + protected: + const int k_count = 100000; // Большой массив для проверки производительности + InType input_data; void SetUp() override { std::mt19937 gen(42); std::uniform_real_distribution dist(-5000.0, 5000.0); - - input_data_.resize(kCount_); - for (auto& val : input_data_) { + + input_data.resize(k_count); + for (auto &val : input_data) { val = dist(gen); } } bool CheckTestOutputData(OutType &output_data) final { // В перф тестах достаточно проверить, что массив просто отсортирован - return std::is_sorted(output_data.begin(), output_data.end()); + return std::ranges::is_sorted(output_data); } InType GetTestInputData() final { - return input_data_; + return input_data; } }; @@ -40,14 +40,13 @@ TEST_P(DorofeevIPerfTestThreads, RunPerfModes) { ExecuteTest(GetParam()); } -const auto kAllPerfTasks = - ppc::util::MakeAllPerfTasks( - PPC_SETTINGS_dorofeev_i_bitwise_sort_double_eo_batcher_merge); +const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_dorofeev_i_bitwise_sort_double_eo_batcher_merge); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); @@ -57,4 +56,4 @@ INSTANTIATE_TEST_SUITE_P(RunModeTests, DorofeevIPerfTestThreads, kGtestValues, k } // namespace -} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge \ No newline at end of file +} // namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge From a5ec30eb15c3db327dfaae53c1d9c9b9a11bdb30 Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Fri, 20 Feb 2026 15:07:48 +0000 Subject: [PATCH 4/7] clang --- .../all/src/ops_all.cpp | 1 + .../omp/src/ops_omp.cpp | 1 + .../seq/src/ops_seq.cpp | 70 ++++++++++--------- .../stl/src/ops_stl.cpp | 1 + .../tbb/src/ops_tbb.cpp | 1 + .../tests/functional/main.cpp | 6 +- .../tests/performance/main.cpp | 7 +- 7 files changed, 47 insertions(+), 40 deletions(-) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp index 1ab6a7be..cbdfa934 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/src/ops_all.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/all/include/ops_all.hpp" + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp index 3110986d..ac473750 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/src/ops_omp.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/omp/include/ops_omp.hpp" + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp index 4d23bc71..c5611b63 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/src/ops_seq.cpp @@ -1,43 +1,40 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/include/ops_seq.hpp" -#include - -#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" #include +#include #include #include #include #include +#include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" + namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { namespace { -// Преобразование double в uint64_t с сохранением порядка сортировки uint64_t DoubleToUint(double d) { uint64_t u = 0; std::memcpy(&u, &d, sizeof(double)); if ((u & 0x8000000000000000ULL) != 0) { - u = ~u; // Инвертируем все биты для отрицательных + u = ~u; } else { - u |= 0x8000000000000000ULL; // Инвертируем только знаковый бит для положительных + u |= 0x8000000000000000ULL; } return u; } -// Обратное преобразование double UintToDouble(uint64_t u) { if ((u & 0x8000000000000000ULL) != 0) { u &= ~0x8000000000000000ULL; } else { u = ~u; } - double d = NAN; + double d = 0.0; std::memcpy(&d, &u, sizeof(double)); return d; } -// Поразрядная сортировка подмассива void RadixSortDouble(std::vector &arr) { if (arr.empty()) { return; @@ -49,12 +46,12 @@ void RadixSortDouble(std::vector &arr) { } std::vector temp(uarr.size()); - for (int byte = 0; byte < 8; ++byte) { - int count[256] = {0}; + for (size_t byte = 0; byte < 8; ++byte) { + std::vector count(256, 0); for (uint64_t val : uarr) { count[(val >> (byte * 8)) & 0xFF]++; } - for (int i = 1; i < 256; ++i) { + for (size_t i = 1; i < 256; ++i) { count[i] += count[i - 1]; } for (int i = static_cast(uarr.size()) - 1; i >= 0; --i) { @@ -68,20 +65,30 @@ void RadixSortDouble(std::vector &arr) { } } -// Четно-нечетное слияние Бэтчера -void OddEvenMerge(std::vector &arr, int l, int n, int step) { - int m = step * 2; - if (m < n) { - OddEvenMerge(arr, l, n, m); - OddEvenMerge(arr, l + step, n, m); - for (int i = l + step; i + step < l + n; i += m) { - if (arr[i] > arr[i + step]) { - std::swap(arr[i], arr[i + step]); - } +// Вынесли операцию сравнения и перестановки блоков в отдельную функцию +void CompareExchangeBlocks(std::vector &arr, size_t i, size_t step) { + for (size_t k = 0; k < step; ++k) { + if (arr[i + k] > arr[i + k + step]) { + std::swap(arr[i + k], arr[i + k + step]); } - } else { - if (l + step < l + n && arr[l] > arr[l + step]) { - std::swap(arr[l], arr[l + step]); + } +} + +// Теперь функция выглядит максимально просто и элегантно +void OddEvenMergeIterative(std::vector &arr, size_t n) { + if (n <= 1) { + return; + } + + // Первая фаза слияния + size_t step = n / 2; + CompareExchangeBlocks(arr, 0, step); + + // Последующие фазы + step /= 2; + for (; step > 0; step /= 2) { + for (size_t i = step; i < n - step; i += step * 2) { + CompareExchangeBlocks(arr, i, step); } } } @@ -94,7 +101,7 @@ DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::DorofeevIBitwiseSortDoubleEOBatcher } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::ValidationImpl() { - return true; // Сортировка пустого массива тоже валидна + return true; } bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::PreProcessingImpl() { @@ -109,7 +116,6 @@ bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { size_t original_size = local_data_.size(); - // Добиваем до ближайшей степени двойки size_t pow2 = 1; while (pow2 < original_size) { pow2 *= 2; @@ -119,20 +125,18 @@ bool DorofeevIBitwiseSortDoubleEOBatcherMergeSEQ::RunImpl() { local_data_.resize(pow2, std::numeric_limits::max()); } - // Для SEQ версии бьем на 2 части, сортируем их и сливаем Бэтчером (имитация параллелизма) size_t mid = pow2 / 2; - std::vector left(local_data_.begin(), local_data_.begin() + mid); - std::vector right(local_data_.begin() + mid, local_data_.end()); + std::vector left(local_data_.begin(), local_data_.begin() + static_cast(mid)); + std::vector right(local_data_.begin() + static_cast(mid), local_data_.end()); RadixSortDouble(left); RadixSortDouble(right); std::ranges::copy(left, local_data_.begin()); - std::ranges::copy(right, local_data_.begin() + mid); + std::ranges::copy(right, local_data_.begin() + static_cast(mid)); - OddEvenMerge(local_data_, 0, pow2, 1); + OddEvenMergeIterative(local_data_, pow2); - // Отрезаем фиктивные элементы if (pow2 > original_size) { local_data_.resize(original_size); } diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp index 6e6974ca..834b0f00 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/src/ops_stl.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/stl/include/ops_stl.hpp" + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp index b4edcc1d..05e7d187 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/src/ops_tbb.cpp @@ -1,4 +1,5 @@ #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/tbb/include/ops_tbb.hpp" + #include "dorofeev_i_bitwise_sort_double_eo_batcher_merge/common/include/common.hpp" namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp index bfa8b116..a5efd78e 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/functional/main.cpp @@ -23,14 +23,10 @@ class DorofeevIRunFuncTestsThreads : public ppc::util::BaseRunFuncTests(ppc::util::GTestParamIndex::kTestParams)>(GetParam()); - - // 2. И уже из нашего кортежа берем размер массива (нулевой элемент) int size = std::get<0>(params); - // Настраиваем генератор случайных чисел - std::mt19937 gen(42); // Фиксированный сид для стабильности тестов + std::mt19937 gen(static_cast(size)); std::uniform_real_distribution dist(-1000.0, 1000.0); input_data_.resize(size); diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp index 53dd4125..42016d00 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/tests/performance/main.cpp @@ -11,11 +11,14 @@ namespace dorofeev_i_bitwise_sort_double_eo_batcher_merge { class DorofeevIPerfTestThreads : public ppc::util::BaseRunPerfTests { protected: - const int k_count = 100000; // Большой массив для проверки производительности + // Вот эти две переменные, которые "потерял" редактор: + const int k_count = 100000; InType input_data; void SetUp() override { - std::mt19937 gen(42); + // Честный случайный сид по стандарту безопасности + std::random_device rd; + std::mt19937 gen(rd()); std::uniform_real_distribution dist(-5000.0, 5000.0); input_data.resize(k_count); From 073fa8b2caa4ae1b930bbd5f11b36e851806c191 Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Fri, 20 Feb 2026 15:34:15 +0000 Subject: [PATCH 5/7] fixing pre-commit --- .../info.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json index ed1c2a00..8d0eabd5 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "Иван", - "group_number": "3823Б1ФИ1", - "last_name": "Дорофеев", - "middle_name": "Денисович", + "first_name": "\u0418\u0432\u0430\u043d", + "group_number": "3823\u04111\u0424\u04181", + "last_name": "\u0414\u043e\u0440\u043e\u0444\u0435\u0435\u0432", + "middle_name": "\u0414\u0435\u043d\u0438\u0441\u043e\u0432\u0438\u0447", "task_number": "1" } } From 0bbd4c08bdebda6954d6f330416e71cf3360d71d Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Tue, 24 Feb 2026 15:02:36 +0000 Subject: [PATCH 6/7] pre-commit attempt 2 --- .../seq/report.md | 1 + 1 file changed, 1 insertion(+) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md index e69de29b..9c558e35 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/seq/report.md @@ -0,0 +1 @@ +. From cad6b408097dee28d57c643b44cbb9a710889ed5 Mon Sep 17 00:00:00 2001 From: 4elodoy-Molovek Date: Tue, 24 Feb 2026 15:06:28 +0000 Subject: [PATCH 7/7] pre-commit --- .../info.json | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json index 8d0eabd5..ed1c2a00 100644 --- a/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json +++ b/tasks/dorofeev_i_bitwise_sort_double_eo_batcher_merge/info.json @@ -1,9 +1,9 @@ { "student": { - "first_name": "\u0418\u0432\u0430\u043d", - "group_number": "3823\u04111\u0424\u04181", - "last_name": "\u0414\u043e\u0440\u043e\u0444\u0435\u0435\u0432", - "middle_name": "\u0414\u0435\u043d\u0438\u0441\u043e\u0432\u0438\u0447", + "first_name": "Иван", + "group_number": "3823Б1ФИ1", + "last_name": "Дорофеев", + "middle_name": "Денисович", "task_number": "1" } }