From 3e58ba2a82c712deef50e70fe35bb1731ac23ff1 Mon Sep 17 00:00:00 2001 From: Kirill Date: Sat, 28 Feb 2026 12:58:21 +0300 Subject: [PATCH 01/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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/19] 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() {