From 3e58ba2a82c712deef50e70fe35bb1731ac23ff1 Mon Sep 17 00:00:00 2001 From: Kirill Date: Sat, 28 Feb 2026 12:58:21 +0300 Subject: [PATCH 01/37] feat(seq): Added function for Cannon algorithm MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit MultiplyBlock - Multiplies two block matrices of size block_size × block_size ShiftBlocksLeft - Performs a cyclic shift of the blocks of matrix A to the left ShiftBlocksUp - Performs a cyclic shift of the blocks of matrix B up RunCannonCycle - Main loop of Cannon's algorithm InitializeBlocks - Initial distribution of blocks according to Cannon's algorithm AssembleOutput - Собирает результат из блоков в итоговую матрицу --- .../seq/include/ops_seq.hpp | 1 + 1 file changed, 1 insertion(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp index 760c14978..83ca8b487 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" From 35eb7e6e0f2d20e3f91b58784e685b5e80305394 Mon Sep 17 00:00:00 2001 From: Kirill Date: Sat, 28 Feb 2026 13:04:06 +0300 Subject: [PATCH 02/37] feat(seq): Added Helpd methods and main methods realization --- .../seq/src/ops_seq.cpp | 2 -- 1 file changed, 2 deletions(-) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp index a9aa5969a..6c423f25f 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp @@ -4,8 +4,6 @@ #include #include -#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" - namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { RemizovKDenseMatrixMultiplicationCannonAlgorithm::RemizovKDenseMatrixMultiplicationCannonAlgorithm(const InType &in) { From 22fe834ba87530ce7e555bb8b38a5b7ef86e7166 Mon Sep 17 00:00:00 2001 From: Kirill Date: Sat, 28 Feb 2026 14:25:13 +0300 Subject: [PATCH 03/37] fix(seq): clang-tidy (pull_request) fix in ci --- .../seq/include/ops_seq.hpp | 1 - .../seq/src/ops_seq.cpp | 2 ++ 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp index 83ca8b487..760c14978 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp @@ -1,6 +1,5 @@ #pragma once -#include #include #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp index 6c423f25f..a9aa5969a 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/src/ops_seq.cpp @@ -4,6 +4,8 @@ #include #include +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" + namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { RemizovKDenseMatrixMultiplicationCannonAlgorithm::RemizovKDenseMatrixMultiplicationCannonAlgorithm(const InType &in) { From eb44c3271b004c2c9c64ffc57355197f29887174 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:10:47 +0300 Subject: [PATCH 04/37] fix(tests): restrrict tests calls in one place --- .../tests/functional/main.cpp | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp index c151fbc76..39d753e72 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp @@ -102,22 +102,22 @@ const std::array kTestCases = { std::vector>(4, std::vector(4, 1.0)), std::vector>(4, std::vector(4, 4.0)))}; +const auto kTestNameFunc = RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests::PrintFuncTestName< + RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests>; + +} // namespace + +namespace { + const auto kTestTasksList = std::tuple_cat(ppc::util::AddFuncTask( kTestCases, PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm)); const auto kGtestValues = ppc::util::ExpandToValues(kTestTasksList); -const auto kTestNameFunc = RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests::PrintFuncTestName< - RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests>; - INSTANTIATE_TEST_SUITE_P(CannonTests, RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests, kGtestValues, kTestNameFunc); -} // namespace - -namespace { - const auto kTestTasksListOmp = std::tuple_cat(ppc::util::AddFuncTask( kTestCases, PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm)); From b10a22fda091aeac989581f21cc25beb2ed96e4c Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:13:05 +0300 Subject: [PATCH 05/37] feat(tbb): initialize TBB class --- .../tbb/include/ops_tbb.hpp | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) create mode 100644 tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp new file mode 100644 index 000000000..0bf3995ba --- /dev/null +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp @@ -0,0 +1,26 @@ +#pragma once + +#include + +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { + +class RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kTBB; + } + + explicit RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; + +}; + +} // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From d3ec6f934a73cfe72453bf10360bce4e9958771a Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:13:45 +0300 Subject: [PATCH 06/37] feat(tbb): Added sub methods in header --- .../tbb/include/ops_tbb.hpp | 28 +++++++++++++++++++ 1 file changed, 28 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp index 0bf3995ba..48b3beaa2 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp @@ -21,6 +21,34 @@ class RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb : public BaseTask { bool RunImpl() override; bool PostProcessingImpl() override; + static void MultiplyBlock(const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size); + + static void ShiftBlocksLeft(std::vector>>> &matrix_blocks, + int block_count); + + static void ShiftBlocksUp(std::vector>>> &matrix_blocks, + int block_count); + + static void RunCannonCycle(std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + std::vector>>> &c_blocks, + int block_size, + int block_count); + + static void AssembleOutput(std::vector>>> &c_blocks, + std::vector> &output, + int block_size, + int block_count); + + static void InitializeBlocks(const std::vector> &matrix_a, + const std::vector> &matrix_b, + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + int block_size, + int block_count); }; } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 0ce6b5e57072066f4726d4c1234aaa87858bfdf0 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:16:05 +0300 Subject: [PATCH 07/37] feat(tbb): Based constructor realization --- .../tbb/src/ops_tbb.cpp | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) create mode 100644 tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp new file mode 100644 index 000000000..cbeb6901a --- /dev/null +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -0,0 +1,20 @@ +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" + +#include +#include +#include + +#include +#include + +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" + +namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { + +RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb( + const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; +} + +} // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 6629d4c77dcaa215f1b06594b299069405eda631 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:16:55 +0300 Subject: [PATCH 08/37] feat(tbb): ValidationImpl realization --- .../tbb/src/ops_tbb.cpp | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index cbeb6901a..075c93534 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -17,4 +17,29 @@ RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RemizovKDenseMatrixMultipli GetInput() = in; } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ValidationImpl() { + const auto &input_data = GetInput(); + + int block_dim = std::get<0>(input_data); + const auto &mat_a = std::get<1>(input_data); + const auto &mat_b = std::get<2>(input_data); + + if (block_dim <= 0) { + return false; + } + if (mat_a.empty() || mat_b.empty()) { + return false; + } + + size_t n = mat_a.size(); + if (n != mat_a[0].size()) { + return false; + } + if (n != mat_b.size() || n != mat_b[0].size()) { + return false; + } + + return (n % static_cast(block_dim) == 0); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From a7e5debb7d78a237b6b7c7bbcb5b38502d3c8ba5 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:18:13 +0300 Subject: [PATCH 09/37] feat(tbb): PreprocessingImpl realization --- .../tbb/src/ops_tbb.cpp | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index 075c93534..d90f4be93 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -42,4 +42,9 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ValidationImpl() { return (n % static_cast(block_dim) == 0); } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::PreProcessingImpl() { + GetOutput().clear(); + return true; +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 5f1f9eba59d9e728a5eb7e61df902f496a95a1f3 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:19:09 +0300 Subject: [PATCH 10/37] feat(tbb): MiltiplyBlock realization --- .../tbb/src/ops_tbb.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index d90f4be93..b4de408ee 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -47,4 +47,20 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::PreProcessingImpl() { return true; } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::MultiplyBlock( + const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size) { + for (int i = 0; i < block_size; ++i) { + for (int j = 0; j < block_size; ++j) { + double accumulator = 0.0; + for (int k = 0; k < block_size; ++k) { + accumulator += a[i][k] * b[k][j]; + } + c[i][j] += accumulator; + } + } +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 641ad900dabb284b042765db29929011b3994cf8 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:20:15 +0300 Subject: [PATCH 11/37] feat(tbb): ShiftBlocksLeft realization --- .../tbb/src/ops_tbb.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index b4de408ee..91769d930 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -63,4 +63,17 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::MultiplyBlock( } } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksLeft( + std::vector>>> &matrix_blocks, + int block_count) { + // Parallelize over rows; each row shift is independent + tbb::parallel_for(0, block_count, [&](int i) { + auto first_element = std::move(matrix_blocks[i][0]); + for (int j = 1; j < block_count; ++j) { + matrix_blocks[i][j - 1] = std::move(matrix_blocks[i][j]); + } + matrix_blocks[i][block_count - 1] = std::move(first_element); + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 5ee7f51d085ded96ef10135c3681f4b5cd74f8c9 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:20:45 +0300 Subject: [PATCH 12/37] feat(tbb): ShiftBlocksUp realization --- .../tbb/src/ops_tbb.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index 91769d930..0b12440bd 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -76,4 +76,17 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksLeft( }); } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksUp( + std::vector>>> &matrix_blocks, + int block_count) { + // Parallelize over columns; each column shift is independent + tbb::parallel_for(0, block_count, [&](int j) { + auto first_element = std::move(matrix_blocks[0][j]); + for (int i = 1; i < block_count; ++i) { + matrix_blocks[i - 1][j] = std::move(matrix_blocks[i][j]); + } + matrix_blocks[block_count - 1][j] = std::move(first_element); + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 860a4de92296608fa25343bc1df32c51bca2f33d Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:22:38 +0300 Subject: [PATCH 13/37] feat(tbb): RunCannonCycle realization --- .../tbb/src/ops_tbb.cpp | 25 +++++++++++++++++++ 1 file changed, 25 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index 0b12440bd..ed0795b5b 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -89,4 +89,29 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksUp( }); } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunCannonCycle( + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + std::vector>>> &c_blocks, + int block_size, + int block_count) { + for (int step = 0; step < block_count; ++step) { + // Parallel multiplication of all block pairs + tbb::parallel_for( + tbb::blocked_range2d(0, block_count, 0, block_count), + [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); + } + } + }); + + if (step < block_count - 1) { + ShiftBlocksLeft(a_blocks, block_count); + ShiftBlocksUp(b_blocks, block_count); + } + } +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 0ecb61256e251ea598bd7bec6ee903d6cdb321ec Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:23:47 +0300 Subject: [PATCH 14/37] feat(tbb): InitializeBlocks realization --- .../tbb/src/ops_tbb.cpp | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index ed0795b5b..1e2e86348 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -114,4 +114,28 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunCannonCycle( } } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::InitializeBlocks( + const std::vector> &matrix_a, + const std::vector> &matrix_b, + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + int block_size, + int block_count) { + tbb::parallel_for( + tbb::blocked_range2d(0, block_count, 0, block_count), + [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + int shift_value = (i + j) % block_count; + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift_value * block_size) + bj]; + b_blocks[i][j][bi][bj] = matrix_b[(shift_value * block_size) + bi][(j * block_size) + bj]; + } + } + } + } + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 2529984f03fdfa069ea2a1000f6c847d67fa5458 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:24:27 +0300 Subject: [PATCH 15/37] feat(tbb): AssembleOutput realization --- .../tbb/src/ops_tbb.cpp | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index 1e2e86348..8616d98a0 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -138,4 +138,24 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::InitializeBlocks( }); } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::AssembleOutput( + std::vector>>> &c_blocks, + std::vector> &output, + int block_size, + int block_count) { + tbb::parallel_for( + tbb::blocked_range2d(0, block_count, 0, block_count), + [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; + } + } + } + } + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From b0d616cab0db7936f98531f0b025b4c33afadbb4 Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:25:32 +0300 Subject: [PATCH 16/37] feat(tbb): RunImpl realization --- .../tbb/src/ops_tbb.cpp | 35 +++++++++++++++++++ 1 file changed, 35 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index 8616d98a0..ea0a740af 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -158,4 +158,39 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::AssembleOutput( }); } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunImpl() { + const auto ¶ms = GetInput(); + + int block_dim = std::get<0>(params); + const auto &source_a = std::get<1>(params); + const auto &source_b = std::get<2>(params); + + int matrix_size = static_cast(source_a.size()); + int blocks_per_dim = matrix_size / block_dim; + + std::vector>>> blocks_a( + blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + + std::vector>>> blocks_b( + blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + + std::vector>>> blocks_c( + blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + + InitializeBlocks(source_a, source_b, blocks_a, blocks_b, block_dim, blocks_per_dim); + RunCannonCycle(blocks_a, blocks_b, blocks_c, block_dim, blocks_per_dim); + + std::vector> result(matrix_size, std::vector(matrix_size, 0.0)); + AssembleOutput(blocks_c, result, block_dim, blocks_per_dim); + + GetOutput() = std::move(result); + return true; +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From faf7c21cc54ea751710789f4a8cd409f63baa45b Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:26:13 +0300 Subject: [PATCH 17/37] feat(tbb): PostProcessingImpl realization --- .../tbb/src/ops_tbb.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index ea0a740af..a6e0d42dd 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -193,4 +193,8 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunImpl() { return true; } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::PostProcessingImpl() { + return true; +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 1295bacc76bdbcf99ce63343371e37b37ef1a8fc Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:26:32 +0300 Subject: [PATCH 18/37] feat(tests): Add functional and perf tests --- .../tests/functional/main.cpp | 10 ++++++++++ .../tests/performance/main.cpp | 13 +++++++++++++ 2 files changed, 23 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp index 39d753e72..90d623baa 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp @@ -10,6 +10,7 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "util/include/func_test_util.hpp" #include "util/include/util.hpp" @@ -127,6 +128,15 @@ const auto kGtestValuesOmp = ppc::util::ExpandToValues(kTestTasksListOmp); INSTANTIATE_TEST_SUITE_P(CannonTestsOmp, RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests, kGtestValuesOmp, kTestNameFunc); +const auto kTestTasksListTbb = + std::tuple_cat(ppc::util::AddFuncTask( + kTestCases, PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm)); + +const auto kGtestValuesTbb = ppc::util::ExpandToValues(kTestTasksListTbb); + +INSTANTIATE_TEST_SUITE_P(CannonTestsTbb, RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests, kGtestValuesTbb, + kTestNameFunc); + } // namespace } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp index 54577fb89..129e71fe0 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp @@ -8,6 +8,7 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "util/include/perf_test_util.hpp" namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { @@ -88,4 +89,16 @@ INSTANTIATE_TEST_SUITE_P(PerfTestsOmp, RemizovKDenseMatrixMultiplicationCannonAl } // namespace +namespace { + +const auto kAllPerfTasksTbb = ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm); + +const auto kGtestValuesTbb = ppc::util::TupleToGTestValues(kAllPerfTasksTbb); + +INSTANTIATE_TEST_SUITE_P(PerfTestsTbb, RemizovKDenseMatrixMultiplicationCannonAlgorithmPerfTests, kGtestValuesTbb, + kPerfTestName); + +} // namespace + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 75b6bcd5516dbaae98b3b5f07670f12275584c2c Mon Sep 17 00:00:00 2001 From: Kirill Date: Mon, 13 Apr 2026 12:28:12 +0300 Subject: [PATCH 19/37] fix(tbb): Clang format fix --- .../tbb/include/ops_tbb.hpp | 19 ++-- .../tbb/src/ops_tbb.cpp | 99 ++++++++----------- 2 files changed, 48 insertions(+), 70 deletions(-) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp index 48b3beaa2..6fb3cd456 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp @@ -21,33 +21,26 @@ class RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb : public BaseTask { bool RunImpl() override; bool PostProcessingImpl() override; - static void MultiplyBlock(const std::vector> &a, - const std::vector> &b, - std::vector> &c, - int block_size); + static void MultiplyBlock(const std::vector> &a, const std::vector> &b, + std::vector> &c, int block_size); static void ShiftBlocksLeft(std::vector>>> &matrix_blocks, int block_count); - static void ShiftBlocksUp(std::vector>>> &matrix_blocks, - int block_count); + static void ShiftBlocksUp(std::vector>>> &matrix_blocks, int block_count); static void RunCannonCycle(std::vector>>> &a_blocks, std::vector>>> &b_blocks, - std::vector>>> &c_blocks, - int block_size, + std::vector>>> &c_blocks, int block_size, int block_count); static void AssembleOutput(std::vector>>> &c_blocks, - std::vector> &output, - int block_size, - int block_count); + std::vector> &output, int block_size, int block_count); static void InitializeBlocks(const std::vector> &matrix_a, const std::vector> &matrix_b, std::vector>>> &a_blocks, - std::vector>>> &b_blocks, - int block_size, + std::vector>>> &b_blocks, int block_size, int block_count); }; diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp index a6e0d42dd..babecb868 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/src/ops_tbb.cpp @@ -1,12 +1,12 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" +#include +#include + #include #include #include -#include -#include - #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { @@ -47,11 +47,10 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::PreProcessingImpl() { return true; } -void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::MultiplyBlock( - const std::vector> &a, - const std::vector> &b, - std::vector> &c, - int block_size) { +void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::MultiplyBlock(const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size) { for (int i = 0; i < block_size; ++i) { for (int j = 0; j < block_size; ++j) { double accumulator = 0.0; @@ -64,8 +63,7 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::MultiplyBlock( } void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksLeft( - std::vector>>> &matrix_blocks, - int block_count) { + std::vector>>> &matrix_blocks, int block_count) { // Parallelize over rows; each row shift is independent tbb::parallel_for(0, block_count, [&](int i) { auto first_element = std::move(matrix_blocks[i][0]); @@ -77,8 +75,7 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksLeft( } void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksUp( - std::vector>>> &matrix_blocks, - int block_count) { + std::vector>>> &matrix_blocks, int block_count) { // Parallelize over columns; each column shift is independent tbb::parallel_for(0, block_count, [&](int j) { auto first_element = std::move(matrix_blocks[0][j]); @@ -92,20 +89,17 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::ShiftBlocksUp( void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunCannonCycle( std::vector>>> &a_blocks, std::vector>>> &b_blocks, - std::vector>>> &c_blocks, - int block_size, - int block_count) { + std::vector>>> &c_blocks, int block_size, int block_count) { for (int step = 0; step < block_count; ++step) { // Parallel multiplication of all block pairs - tbb::parallel_for( - tbb::blocked_range2d(0, block_count, 0, block_count), - [&](const tbb::blocked_range2d &r) { - for (int i = r.rows().begin(); i != r.rows().end(); ++i) { - for (int j = r.cols().begin(); j != r.cols().end(); ++j) { - MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); - } - } - }); + tbb::parallel_for(tbb::blocked_range2d(0, block_count, 0, block_count), + [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); + } + } + }); if (step < block_count - 1) { ShiftBlocksLeft(a_blocks, block_count); @@ -115,47 +109,38 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunCannonCycle( } void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::InitializeBlocks( - const std::vector> &matrix_a, - const std::vector> &matrix_b, + const std::vector> &matrix_a, const std::vector> &matrix_b, std::vector>>> &a_blocks, - std::vector>>> &b_blocks, - int block_size, - int block_count) { - tbb::parallel_for( - tbb::blocked_range2d(0, block_count, 0, block_count), - [&](const tbb::blocked_range2d &r) { - for (int i = r.rows().begin(); i != r.rows().end(); ++i) { - for (int j = r.cols().begin(); j != r.cols().end(); ++j) { - int shift_value = (i + j) % block_count; - for (int bi = 0; bi < block_size; ++bi) { - for (int bj = 0; bj < block_size; ++bj) { - a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift_value * block_size) + bj]; - b_blocks[i][j][bi][bj] = matrix_b[(shift_value * block_size) + bi][(j * block_size) + bj]; - } - } + std::vector>>> &b_blocks, int block_size, int block_count) { + tbb::parallel_for(tbb::blocked_range2d(0, block_count, 0, block_count), [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + int shift_value = (i + j) % block_count; + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift_value * block_size) + bj]; + b_blocks[i][j][bi][bj] = matrix_b[(shift_value * block_size) + bi][(j * block_size) + bj]; } } - }); + } + } + }); } void RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::AssembleOutput( - std::vector>>> &c_blocks, - std::vector> &output, - int block_size, - int block_count) { - tbb::parallel_for( - tbb::blocked_range2d(0, block_count, 0, block_count), - [&](const tbb::blocked_range2d &r) { - for (int i = r.rows().begin(); i != r.rows().end(); ++i) { - for (int j = r.cols().begin(); j != r.cols().end(); ++j) { - for (int bi = 0; bi < block_size; ++bi) { - for (int bj = 0; bj < block_size; ++bj) { - output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; - } - } + std::vector>>> &c_blocks, std::vector> &output, + int block_size, int block_count) { + tbb::parallel_for(tbb::blocked_range2d(0, block_count, 0, block_count), [&](const tbb::blocked_range2d &r) { + for (int i = r.rows().begin(); i != r.rows().end(); ++i) { + for (int j = r.cols().begin(); j != r.cols().end(); ++j) { + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; } } - }); + } + } + }); } bool RemizovKDenseMatrixMultiplicationCannonAlgorithmTbb::RunImpl() { From 24c08b0ddc59bcc9130a8499a9bb3a38f116db15 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:42:18 +0300 Subject: [PATCH 20/37] feat(stl): Initialize stl class --- .../stl/include/ops_stl.hpp | 24 +++++++++++++++++++ 1 file changed, 24 insertions(+) create mode 100644 tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp new file mode 100644 index 000000000..29e4ce442 --- /dev/null +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp @@ -0,0 +1,24 @@ +#pragma once + +#include + +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { + +class RemizovKDenseMatrixMultiplicationCannonAlgorithmStl : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kSTL; + } + + explicit RemizovKDenseMatrixMultiplicationCannonAlgorithmStl(const InType &in); + + private: + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; + +} // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 337e5f1a2d668d07e77039a1dda88580b37a02dc Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:44:00 +0300 Subject: [PATCH 21/37] feat(stl): Added sub methods in header --- .../stl/include/ops_stl.hpp | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp index 29e4ce442..fcc9ea94a 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp @@ -21,4 +21,34 @@ class RemizovKDenseMatrixMultiplicationCannonAlgorithmStl : public BaseTask { bool RunImpl() override; bool PostProcessingImpl() override; + static void MultiplyBlock(const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size); + + static void ShiftBlocksLeft(std::vector>>> &matrix_blocks, + int block_count); + + static void ShiftBlocksUp(std::vector>>> &matrix_blocks, + int block_count); + + static void RunCannonCycle(std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + std::vector>>> &c_blocks, + int block_size, + int block_count); + + static void AssembleOutput(std::vector>>> &c_blocks, + std::vector> &output, + int block_size, + int block_count); + + static void InitializeBlocks(const std::vector> &matrix_a, + const std::vector> &matrix_b, + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + int block_size, + int block_count); +}; + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 57ee153e83b5aa0951c20ef5a045bb8442a3831f Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:48:51 +0300 Subject: [PATCH 22/37] feat(stl): added subfunction ParallelFor Helper function for parallel execution of for from begin to end with division of work between std::thread::hardware_concurrency() threads --- .../stl/src/ops_stl.cpp | 43 +++++++++++++++++++ 1 file changed, 43 insertions(+) create mode 100644 tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp new file mode 100644 index 000000000..9327ce106 --- /dev/null +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -0,0 +1,43 @@ +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp" + +#include +#include +#include +#include +#include +#include + +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" + +namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { + +template +static void ParallelFor(IndexType begin, IndexType end, Func&& func) { + const std::size_t num_threads = std::max(1u, std::thread::hardware_concurrency()); + const IndexType range_length = end - begin; + if (range_length <= 0) return; + + std::vector threads; + threads.reserve(num_threads); + + IndexType chunk_size = (range_length + num_threads - 1) / num_threads; + IndexType start = begin; + + for (std::size_t t = 0; t < num_threads; ++t) { + IndexType chunk_end = std::min(end, start + chunk_size); + if (start >= chunk_end) break; + + threads.emplace_back([start, chunk_end, &func]() { + for (IndexType i = start; i < chunk_end; ++i) { + func(i); + } + }); + start = chunk_end; + } + + for (auto& th : threads) { + if (th.joinable()) th.join(); + } +} + +} // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 5665aa268c787e284866a7ef67cbca1986415402 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:51:52 +0300 Subject: [PATCH 23/37] feat(stl): Added sub function ParallelFor2D Helper function for parallel execution of for from element i to element j with division of work between std::thread::hardware_concurrency() threads --- .../stl/src/ops_stl.cpp | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 9327ce106..c46364243 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -40,4 +40,18 @@ static void ParallelFor(IndexType begin, IndexType end, Func&& func) { } } +template +static void ParallelFor2D(int rows_begin, int rows_end, int cols_begin, int cols_end, Func&& func) { + const int rows = rows_end - rows_begin; + const int cols = cols_end - cols_begin; + const int total = rows * cols; + if (total <= 0) return; + + ParallelFor(0, total, [&](int linear_idx) { + int i = rows_begin + linear_idx / cols; + int j = cols_begin + linear_idx % cols; + func(i, j); + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 91c37e9d53e37fd7fdbe971644f4f34d30a8a9a0 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:53:45 +0300 Subject: [PATCH 24/37] feat(stl): Constructor realization --- .../stl/src/ops_stl.cpp | 8 ++++++++ 1 file changed, 8 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index c46364243..97bd6fa0f 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -54,4 +54,12 @@ static void ParallelFor2D(int rows_begin, int rows_end, int cols_begin, int cols }); } + +RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RemizovKDenseMatrixMultiplicationCannonAlgorithmStl( + const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetInput() = in; +} + + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 0553ce5a81f6cf1e51ed5c2c5b797093b4199d93 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:54:36 +0300 Subject: [PATCH 25/37] feat(stl): ValidationImpl realization --- .../stl/src/ops_stl.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 97bd6fa0f..9bc9b067d 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -62,4 +62,20 @@ RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RemizovKDenseMatrixMultipli } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ValidationImpl() { + const auto &input_data = GetInput(); + int block_dim = std::get<0>(input_data); + const auto &mat_a = std::get<1>(input_data); + const auto &mat_b = std::get<2>(input_data); + + if (block_dim <= 0) return false; + if (mat_a.empty() || mat_b.empty()) return false; + + size_t n = mat_a.size(); + if (n != mat_a[0].size()) return false; + if (n != mat_b.size() || n != mat_b[0].size()) return false; + + return (n % static_cast(block_dim) == 0); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 9dbd2275653208509358160718fa83167365c98b Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:55:17 +0300 Subject: [PATCH 26/37] feat(stl): PreProcessingImpl realization --- .../stl/src/ops_stl.cpp | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 9bc9b067d..159eb833f 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -78,4 +78,10 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ValidationImpl() { return (n % static_cast(block_dim) == 0); } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::PreProcessingImpl() { + GetOutput().clear(); + return true; +} + + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From dad4fe1b7ff0de466ff3e610b313977cb54f41e1 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:56:11 +0300 Subject: [PATCH 27/37] feat(stl): MultiplyBlock realization --- .../stl/src/ops_stl.cpp | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 159eb833f..b51a0a7e1 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -84,4 +84,20 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::PreProcessingImpl() { } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::MultiplyBlock( + const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size) { + for (int i = 0; i < block_size; ++i) { + for (int j = 0; j < block_size; ++j) { + double acc = 0.0; + for (int k = 0; k < block_size; ++k) { + acc += a[i][k] * b[k][j]; + } + c[i][j] += acc; + } + } +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From fcf2f523139db3dca24c3a944e32a36dc7e8919d Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:56:52 +0300 Subject: [PATCH 28/37] feat(stl): ShiftBlocksLeft realization --- .../stl/src/ops_stl.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index b51a0a7e1..f1b22706d 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -100,4 +100,17 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::MultiplyBlock( } } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksLeft( + std::vector>>> &matrix_blocks, + int block_count) { + ParallelFor(0, block_count, [&](int i) { + auto first = std::move(matrix_blocks[i][0]); + for (int j = 1; j < block_count; ++j) { + matrix_blocks[i][j - 1] = std::move(matrix_blocks[i][j]); + } + matrix_blocks[i][block_count - 1] = std::move(first); + }); +} + + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 2453457ce9828638f2c9f49bd6ab01a95433c3e2 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:57:26 +0300 Subject: [PATCH 29/37] feat(stl): ShiftBlocksUp realization --- .../stl/src/ops_stl.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index f1b22706d..d6a7fee78 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -113,4 +113,17 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksLeft( } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksUp( + std::vector>>> &matrix_blocks, + int block_count) { + ParallelFor(0, block_count, [&](int j) { + auto first = std::move(matrix_blocks[0][j]); + for (int i = 1; i < block_count; ++i) { + matrix_blocks[i - 1][j] = std::move(matrix_blocks[i][j]); + } + matrix_blocks[block_count - 1][j] = std::move(first); + }); +} + + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 26f26e19081a83b1a1e4f621eea03b7d250cf4f0 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 20:59:00 +0300 Subject: [PATCH 30/37] feat(stl): RunCannonCycle realization --- .../stl/src/ops_stl.cpp | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index d6a7fee78..a043eaa10 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -126,4 +126,24 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksUp( } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunCannonCycle( + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + std::vector>>> &c_blocks, + int block_size, + int block_count) { + for (int step = 0; step < block_count; ++step) { + ParallelFor2D(0, block_count, 0, block_count, + [&](int i, int j) { + MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); + }); + + if (step < block_count - 1) { + ShiftBlocksLeft(a_blocks, block_count); + ShiftBlocksUp(b_blocks, block_count); + } + } +} + + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From c8f3a436475db6f65c5b7d1fb62f86d45de8294e Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:00:01 +0300 Subject: [PATCH 31/37] feat(stl): InitializeBlocks realization --- .../stl/src/ops_stl.cpp | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index a043eaa10..f38034067 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -146,4 +146,23 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunCannonCycle( } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::InitializeBlocks( + const std::vector> &matrix_a, + const std::vector> &matrix_b, + std::vector>>> &a_blocks, + std::vector>>> &b_blocks, + int block_size, + int block_count) { + ParallelFor2D(0, block_count, 0, block_count, + [&](int i, int j) { + int shift = (i + j) % block_count; + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift * block_size) + bj]; + b_blocks[i][j][bi][bj] = matrix_b[(shift * block_size) + bi][(j * block_size) + bj]; + } + } + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 13f3ea2d7d3cd97191ea92d0e9210e1c12fea356 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:00:34 +0300 Subject: [PATCH 32/37] feat(stl): AssembleOutput realization --- .../stl/src/ops_stl.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index f38034067..c1f7bbe1c 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -165,4 +165,19 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::InitializeBlocks( }); } +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::AssembleOutput( + std::vector>>> &c_blocks, + std::vector> &output, + int block_size, + int block_count) { + ParallelFor2D(0, block_count, 0, block_count, + [&](int i, int j) { + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; + } + } + }); +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 62b616ccbb6392cc32e6dc9da18f3212b9611ac8 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:01:20 +0300 Subject: [PATCH 33/37] feat(stl): RunImpl realization --- .../stl/src/ops_stl.cpp | 30 +++++++++++++++++++ 1 file changed, 30 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index c1f7bbe1c..9976829cd 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -180,4 +180,34 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::AssembleOutput( }); } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunImpl() { + const auto ¶ms = GetInput(); + int block_dim = std::get<0>(params); + const auto &source_a = std::get<1>(params); + const auto &source_b = std::get<2>(params); + + int matrix_size = static_cast(source_a.size()); + int blocks_per_dim = matrix_size / block_dim; + + using Block4D = std::vector>>>; + Block4D blocks_a(blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + Block4D blocks_b(blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + Block4D blocks_c(blocks_per_dim, + std::vector>>( + blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + + InitializeBlocks(source_a, source_b, blocks_a, blocks_b, block_dim, blocks_per_dim); + RunCannonCycle(blocks_a, blocks_b, blocks_c, block_dim, blocks_per_dim); + + std::vector> result(matrix_size, std::vector(matrix_size, 0.0)); + AssembleOutput(blocks_c, result, block_dim, blocks_per_dim); + + GetOutput() = std::move(result); + return true; +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From f1532fd6ee84a79340daef6efb9e9bb5b5f9a030 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:01:52 +0300 Subject: [PATCH 34/37] feat(stl): PostProcessingImpl realization --- .../stl/src/ops_stl.cpp | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 9976829cd..4c4d98fb2 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -210,4 +210,8 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunImpl() { return true; } +bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::PostProcessingImpl() { + return true; +} + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 6a355e7e64c7fdf386621592f67f5122c8582e35 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:02:22 +0300 Subject: [PATCH 35/37] feat(tests): Functional for stl --- .../tests/functional/main.cpp | 10 ++++++++++ 1 file changed, 10 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp index 90d623baa..48c191116 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp @@ -11,6 +11,7 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp" #include "util/include/func_test_util.hpp" #include "util/include/util.hpp" @@ -137,6 +138,15 @@ const auto kGtestValuesTbb = ppc::util::ExpandToValues(kTestTasksListTbb); INSTANTIATE_TEST_SUITE_P(CannonTestsTbb, RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests, kGtestValuesTbb, kTestNameFunc); +const auto kTestTasksListStl = + std::tuple_cat(ppc::util::AddFuncTask( + kTestCases, PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm)); + +const auto kGtestValuesStl = ppc::util::ExpandToValues(kTestTasksListStl); + +INSTANTIATE_TEST_SUITE_P(CannonTestsStl, RemizovKDenseMatrixMultiplicationCannonAlgorithmFuncTests, kGtestValuesStl, + kTestNameFunc); + } // namespace } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From eb78b09e5ad9976330a714c624ee3388ff54c3e1 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:02:53 +0300 Subject: [PATCH 36/37] feat(tests): perf for stl --- .../tests/performance/main.cpp | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp index 129e71fe0..8e1857b37 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp @@ -9,6 +9,7 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp" #include "util/include/perf_test_util.hpp" namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { @@ -101,4 +102,16 @@ INSTANTIATE_TEST_SUITE_P(PerfTestsTbb, RemizovKDenseMatrixMultiplicationCannonAl } // namespace +namespace { + +const auto kAllPerfTasksStl = ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_remizov_k_dense_matrix_multiplication_cannon_algorithm); + +const auto kGtestValuesStl = ppc::util::TupleToGTestValues(kAllPerfTasksStl); + +INSTANTIATE_TEST_SUITE_P(PerfTestsStl, RemizovKDenseMatrixMultiplicationCannonAlgorithmPerfTests, kGtestValuesStl, + kPerfTestName); + +} // namespace + } // namespace remizov_k_dense_matrix_multiplication_cannon_algorithm From 74ae341787acd702043fc106ad0f27cacdc94c03 Mon Sep 17 00:00:00 2001 From: Kirill Date: Thu, 16 Apr 2026 21:06:54 +0300 Subject: [PATCH 37/37] fix(stl): clang fix --- .../stl/include/ops_stl.hpp | 19 +-- .../stl/src/ops_stl.cpp | 134 +++++++++--------- .../tests/functional/main.cpp | 2 +- .../tests/performance/main.cpp | 2 +- 4 files changed, 73 insertions(+), 84 deletions(-) diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp index fcc9ea94a..0db897125 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp @@ -21,33 +21,26 @@ class RemizovKDenseMatrixMultiplicationCannonAlgorithmStl : public BaseTask { bool RunImpl() override; bool PostProcessingImpl() override; - static void MultiplyBlock(const std::vector> &a, - const std::vector> &b, - std::vector> &c, - int block_size); + static void MultiplyBlock(const std::vector> &a, const std::vector> &b, + std::vector> &c, int block_size); static void ShiftBlocksLeft(std::vector>>> &matrix_blocks, int block_count); - static void ShiftBlocksUp(std::vector>>> &matrix_blocks, - int block_count); + static void ShiftBlocksUp(std::vector>>> &matrix_blocks, int block_count); static void RunCannonCycle(std::vector>>> &a_blocks, std::vector>>> &b_blocks, - std::vector>>> &c_blocks, - int block_size, + std::vector>>> &c_blocks, int block_size, int block_count); static void AssembleOutput(std::vector>>> &c_blocks, - std::vector> &output, - int block_size, - int block_count); + std::vector> &output, int block_size, int block_count); static void InitializeBlocks(const std::vector> &matrix_a, const std::vector> &matrix_b, std::vector>>> &a_blocks, - std::vector>>> &b_blocks, - int block_size, + std::vector>>> &b_blocks, int block_size, int block_count); }; diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp index 4c4d98fb2..fb3bbe2d6 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/src/ops_stl.cpp @@ -2,20 +2,22 @@ #include #include +#include #include #include #include -#include #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" namespace remizov_k_dense_matrix_multiplication_cannon_algorithm { template -static void ParallelFor(IndexType begin, IndexType end, Func&& func) { +static void ParallelFor(IndexType begin, IndexType end, Func &&func) { const std::size_t num_threads = std::max(1u, std::thread::hardware_concurrency()); const IndexType range_length = end - begin; - if (range_length <= 0) return; + if (range_length <= 0) { + return; + } std::vector threads; threads.reserve(num_threads); @@ -25,7 +27,9 @@ static void ParallelFor(IndexType begin, IndexType end, Func&& func) { for (std::size_t t = 0; t < num_threads; ++t) { IndexType chunk_end = std::min(end, start + chunk_size); - if (start >= chunk_end) break; + if (start >= chunk_end) { + break; + } threads.emplace_back([start, chunk_end, &func]() { for (IndexType i = start; i < chunk_end; ++i) { @@ -35,17 +39,21 @@ static void ParallelFor(IndexType begin, IndexType end, Func&& func) { start = chunk_end; } - for (auto& th : threads) { - if (th.joinable()) th.join(); + for (auto &th : threads) { + if (th.joinable()) { + th.join(); + } } } template -static void ParallelFor2D(int rows_begin, int rows_end, int cols_begin, int cols_end, Func&& func) { +static void ParallelFor2D(int rows_begin, int rows_end, int cols_begin, int cols_end, Func &&func) { const int rows = rows_end - rows_begin; const int cols = cols_end - cols_begin; const int total = rows * cols; - if (total <= 0) return; + if (total <= 0) { + return; + } ParallelFor(0, total, [&](int linear_idx) { int i = rows_begin + linear_idx / cols; @@ -54,26 +62,32 @@ static void ParallelFor2D(int rows_begin, int rows_end, int cols_begin, int cols }); } - RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RemizovKDenseMatrixMultiplicationCannonAlgorithmStl( const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); GetInput() = in; } - bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ValidationImpl() { const auto &input_data = GetInput(); int block_dim = std::get<0>(input_data); const auto &mat_a = std::get<1>(input_data); const auto &mat_b = std::get<2>(input_data); - if (block_dim <= 0) return false; - if (mat_a.empty() || mat_b.empty()) return false; + if (block_dim <= 0) { + return false; + } + if (mat_a.empty() || mat_b.empty()) { + return false; + } size_t n = mat_a.size(); - if (n != mat_a[0].size()) return false; - if (n != mat_b.size() || n != mat_b[0].size()) return false; + if (n != mat_a[0].size()) { + return false; + } + if (n != mat_b.size() || n != mat_b[0].size()) { + return false; + } return (n % static_cast(block_dim) == 0); } @@ -83,12 +97,10 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::PreProcessingImpl() { return true; } - -void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::MultiplyBlock( - const std::vector> &a, - const std::vector> &b, - std::vector> &c, - int block_size) { +void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::MultiplyBlock(const std::vector> &a, + const std::vector> &b, + std::vector> &c, + int block_size) { for (int i = 0; i < block_size; ++i) { for (int j = 0; j < block_size; ++j) { double acc = 0.0; @@ -101,8 +113,7 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::MultiplyBlock( } void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksLeft( - std::vector>>> &matrix_blocks, - int block_count) { + std::vector>>> &matrix_blocks, int block_count) { ParallelFor(0, block_count, [&](int i) { auto first = std::move(matrix_blocks[i][0]); for (int j = 1; j < block_count; ++j) { @@ -112,10 +123,8 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksLeft( }); } - void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksUp( - std::vector>>> &matrix_blocks, - int block_count) { + std::vector>>> &matrix_blocks, int block_count) { ParallelFor(0, block_count, [&](int j) { auto first = std::move(matrix_blocks[0][j]); for (int i = 1; i < block_count; ++i) { @@ -125,18 +134,13 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::ShiftBlocksUp( }); } - void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunCannonCycle( std::vector>>> &a_blocks, std::vector>>> &b_blocks, - std::vector>>> &c_blocks, - int block_size, - int block_count) { + std::vector>>> &c_blocks, int block_size, int block_count) { for (int step = 0; step < block_count; ++step) { ParallelFor2D(0, block_count, 0, block_count, - [&](int i, int j) { - MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); - }); + [&](int i, int j) { MultiplyBlock(a_blocks[i][j], b_blocks[i][j], c_blocks[i][j], block_size); }); if (step < block_count - 1) { ShiftBlocksLeft(a_blocks, block_count); @@ -145,39 +149,31 @@ void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunCannonCycle( } } - void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::InitializeBlocks( - const std::vector> &matrix_a, - const std::vector> &matrix_b, + const std::vector> &matrix_a, const std::vector> &matrix_b, std::vector>>> &a_blocks, - std::vector>>> &b_blocks, - int block_size, - int block_count) { - ParallelFor2D(0, block_count, 0, block_count, - [&](int i, int j) { - int shift = (i + j) % block_count; - for (int bi = 0; bi < block_size; ++bi) { - for (int bj = 0; bj < block_size; ++bj) { - a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift * block_size) + bj]; - b_blocks[i][j][bi][bj] = matrix_b[(shift * block_size) + bi][(j * block_size) + bj]; - } - } - }); + std::vector>>> &b_blocks, int block_size, int block_count) { + ParallelFor2D(0, block_count, 0, block_count, [&](int i, int j) { + int shift = (i + j) % block_count; + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + a_blocks[i][j][bi][bj] = matrix_a[(i * block_size) + bi][(shift * block_size) + bj]; + b_blocks[i][j][bi][bj] = matrix_b[(shift * block_size) + bi][(j * block_size) + bj]; + } + } + }); } void RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::AssembleOutput( - std::vector>>> &c_blocks, - std::vector> &output, - int block_size, - int block_count) { - ParallelFor2D(0, block_count, 0, block_count, - [&](int i, int j) { - for (int bi = 0; bi < block_size; ++bi) { - for (int bj = 0; bj < block_size; ++bj) { - output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; - } - } - }); + std::vector>>> &c_blocks, std::vector> &output, + int block_size, int block_count) { + ParallelFor2D(0, block_count, 0, block_count, [&](int i, int j) { + for (int bi = 0; bi < block_size; ++bi) { + for (int bj = 0; bj < block_size; ++bj) { + output[(i * block_size) + bi][(j * block_size) + bj] = c_blocks[i][j][bi][bj]; + } + } + }); } bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunImpl() { @@ -190,15 +186,15 @@ bool RemizovKDenseMatrixMultiplicationCannonAlgorithmStl::RunImpl() { int blocks_per_dim = matrix_size / block_dim; using Block4D = std::vector>>>; - Block4D blocks_a(blocks_per_dim, - std::vector>>( - blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); - Block4D blocks_b(blocks_per_dim, - std::vector>>( - blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); - Block4D blocks_c(blocks_per_dim, - std::vector>>( - blocks_per_dim, std::vector>(block_dim, std::vector(block_dim, 0.0)))); + Block4D blocks_a(blocks_per_dim, std::vector>>( + blocks_per_dim, std::vector>( + block_dim, std::vector(block_dim, 0.0)))); + Block4D blocks_b(blocks_per_dim, std::vector>>( + blocks_per_dim, std::vector>( + block_dim, std::vector(block_dim, 0.0)))); + Block4D blocks_c(blocks_per_dim, std::vector>>( + blocks_per_dim, std::vector>( + block_dim, std::vector(block_dim, 0.0)))); InitializeBlocks(source_a, source_b, blocks_a, blocks_b, block_dim, blocks_per_dim); RunCannonCycle(blocks_a, blocks_b, blocks_c, block_dim, blocks_per_dim); diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp index 48c191116..0b29a4add 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/functional/main.cpp @@ -10,8 +10,8 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" -#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "util/include/func_test_util.hpp" #include "util/include/util.hpp" diff --git a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp index 8e1857b37..23fb35176 100644 --- a/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp +++ b/tasks/remizov_k_dense_matrix_multiplication_cannon_algorithm/tests/performance/main.cpp @@ -8,8 +8,8 @@ #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/common/include/common.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/omp/include/ops_omp.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/seq/include/ops_seq.hpp" -#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "remizov_k_dense_matrix_multiplication_cannon_algorithm/stl/include/ops_stl.hpp" +#include "remizov_k_dense_matrix_multiplication_cannon_algorithm/tbb/include/ops_tbb.hpp" #include "util/include/perf_test_util.hpp" namespace remizov_k_dense_matrix_multiplication_cannon_algorithm {