From 8b00f5cfe6654246480085cafce602ed9f17298c Mon Sep 17 00:00:00 2001 From: sofaprog Date: Tue, 24 Feb 2026 22:20:29 +0300 Subject: [PATCH 01/18] first commit with seq --- .../common/include/common.hpp | 17 ++++ tasks/makoveeva_matmul_double_seq/info.json | 9 ++ tasks/makoveeva_matmul_double_seq/report.md | 0 .../seq/include/ops_seq.hpp | 32 ++++++ .../makoveeva_matmul_double_seq/seq/report.md | 0 .../seq/src/ops_seq.cpp | 74 ++++++++++++++ .../makoveeva_matmul_double_seq/settings.json | 10 ++ .../tests/functional/main.cpp | 85 ++++++++++++++++ .../tests/performance/main.cpp | 99 +++++++++++++++++++ 9 files changed, 326 insertions(+) create mode 100644 tasks/makoveeva_matmul_double_seq/common/include/common.hpp create mode 100644 tasks/makoveeva_matmul_double_seq/info.json create mode 100644 tasks/makoveeva_matmul_double_seq/report.md create mode 100644 tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp create mode 100644 tasks/makoveeva_matmul_double_seq/seq/report.md create mode 100644 tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp create mode 100644 tasks/makoveeva_matmul_double_seq/settings.json create mode 100644 tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp create mode 100644 tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp diff --git a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp new file mode 100644 index 00000000..3ff1691a --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp @@ -0,0 +1,17 @@ +#pragma once + +#include +#include +#include +#include + +#include "task/include/task.hpp" + +namespace makoveeva_matmul_double_seq { + +using InType = std::tuple, std::vector>; +using OutType = std::vector; +using TestType = std::tuple; +using BaseTask = ppc::task::Task; + +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/info.json b/tasks/makoveeva_matmul_double_seq/info.json new file mode 100644 index 00000000..fef624f4 --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/info.json @@ -0,0 +1,9 @@ +{ + "student": { + "first_name": "Софья", + "group_number": "3823Б1ПР1", + "last_name": "Маковеева", + "middle_name": "Игоревна", + "task_number": "1" + } +} diff --git a/tasks/makoveeva_matmul_double_seq/report.md b/tasks/makoveeva_matmul_double_seq/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp new file mode 100644 index 00000000..323989d3 --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp @@ -0,0 +1,32 @@ +#pragma once + +#include + +#include "makoveeva_matmul_double_seq/common/include/common.hpp" +#include "task/include/task.hpp" + +namespace makoveeva_matmul_double_seq { + +class MatmulDoubleSeqTask : public BaseTask { + public: + static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { + return ppc::task::TypeOfTask::kSEQ; + } + + explicit MatmulDoubleSeqTask(const InType &in); + + bool ValidationImpl() override; + bool PreProcessingImpl() override; + bool RunImpl() override; + bool PostProcessingImpl() override; + + const std::vector& GetResult() const { return C_; } + + private: + size_t n_; + std::vector A_; + std::vector B_; + std::vector C_; +}; + +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/seq/report.md b/tasks/makoveeva_matmul_double_seq/seq/report.md new file mode 100644 index 00000000..e69de29b diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp new file mode 100644 index 00000000..81dd89d1 --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -0,0 +1,74 @@ +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" + +#include +#include + +namespace makoveeva_matmul_double_seq { + +MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) { + SetTypeOfTask(GetStaticTypeOfTask()); + + n_ = std::get<0>(in); + A_ = std::get<1>(in); + B_ = std::get<2>(in); + + C_.assign(n_ * n_, 0.0); + GetOutput() = C_; +} + +bool MatmulDoubleSeqTask::ValidationImpl() { + + if (n_ <= 0) return false; + + if (A_.size() != n_ * n_ || B_.size() != n_ * n_) return false; + + return true; +} + +bool MatmulDoubleSeqTask::PreProcessingImpl() { + return true; +} + +bool MatmulDoubleSeqTask::RunImpl() { + if (n_ <= 0) return false; + + + int block_size = std::max(1, static_cast(std::sqrt(n_))); + int num_blocks = (n_ + block_size - 1) / block_size; + + + C_.assign(n_ * n_, 0.0); + + for (int ib = 0; ib < num_blocks; ib++) { + for (int jb = 0; jb < num_blocks; jb++) { + for (int kb = 0; kb < num_blocks; kb++) { + int i_start = ib * block_size; + int i_end = std::min(i_start + block_size, static_cast(n_)); + int j_start = jb * block_size; + int j_end = std::min(j_start + block_size, static_cast(n_)); + int k_start = kb * block_size; + int k_end = std::min(k_start + block_size, static_cast(n_)); + + for (int i = i_start; i < i_end; i++) { + for (int j = j_start; j < j_end; j++) { + double sum = 0.0; + for (int k = k_start; k < k_end; k++) { + sum += A_[i * n_ + k] * B_[k * n_ + j]; + } + C_[i * n_ + j] += sum; + } + } + } + } + } + + GetOutput() = C_; + + return true; +} + +bool MatmulDoubleSeqTask::PostProcessingImpl() { + return true; +} + +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/settings.json b/tasks/makoveeva_matmul_double_seq/settings.json new file mode 100644 index 00000000..0be0208f --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/settings.json @@ -0,0 +1,10 @@ +{ + "tasks": { + "all": "enabled", + "omp": "enabled", + "seq": "enabled", + "stl": "enabled", + "tbb": "enabled" + }, + "tasks_type": "threads" +} diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp new file mode 100644 index 00000000..d4bfcc23 --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -0,0 +1,85 @@ +#include + +#include +#include +#include + +#include "makoveeva_matmul_double_seq/common/include/common.hpp" +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" + +namespace makoveeva_matmul_double_seq { + +std::vector SimpleMultiply(const std::vector& A, + const std::vector& B, + size_t n) { + std::vector C(n * n, 0.0); + for (size_t i = 0; i < n; i++) { + for (size_t j = 0; j < n; j++) { + double sum = 0.0; + for (size_t k = 0; k < n; k++) { + sum += A[i * n + k] * B[k * n + j]; + } + C[i * n + j] = sum; + } + } + return C; +} + + +TEST(MatmulDoubleTest, Test2x2) { + size_t n = 2; + + + std::vector A = {1.0, 2.0, 3.0, 4.0}; + + std::vector B = {5.0, 6.0, 7.0, 8.0}; + std::vector expected = {19.0, 22.0, 43.0, 50.0}; + + auto input = std::make_tuple(n, A, B); + MatmulDoubleSeqTask task(input); + + ASSERT_TRUE(task.ValidationImpl()); + ASSERT_TRUE(task.PreProcessingImpl()); + ASSERT_TRUE(task.RunImpl()); + ASSERT_TRUE(task.PostProcessingImpl()); + + auto result = task.GetResult(); + + for (size_t i = 0; i < result.size(); i++) { + EXPECT_NEAR(result[i], expected[i], 1e-10); + } +} + +TEST(MatmulDoubleTest, TestVariousSizes) { + std::vector sizes = {2, 3, 4, 5, 8}; + + for (size_t n : sizes) { + std::vector A(n * n); + std::vector B(n * n); + + for (size_t i = 0; i < n; i++) { + for (size_t j = 0; j < n; j++) { + A[i * n + j] = static_cast(i + j + 1); + B[i * n + j] = static_cast(i * n + j + 1); + } + } + + auto expected = SimpleMultiply(A, B, n); + auto input = std::make_tuple(n, A, B); + + MatmulDoubleSeqTask task(input); + + ASSERT_TRUE(task.ValidationImpl()) << "Failed validation for n=" << n; + ASSERT_TRUE(task.PreProcessingImpl()) << "Failed preprocessing for n=" << n; + ASSERT_TRUE(task.RunImpl()) << "Failed run for n=" << n; + ASSERT_TRUE(task.PostProcessingImpl()) << "Failed postprocessing for n=" << n; + + auto result = task.GetResult(); + + for (size_t i = 0; i < result.size(); i++) { + EXPECT_NEAR(result[i], expected[i], 1e-10) << "Failed at index " << i << " for n=" << n; + } + } +} + +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp new file mode 100644 index 00000000..59afb51d --- /dev/null +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -0,0 +1,99 @@ +#include + +#include +#include +#include +#include + +#include "makoveeva_matmul_double_seq/common/include/common.hpp" +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" +#include "util/include/perf_test_util.hpp" + +namespace makoveeva_matmul_double_seq { + +class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests { + InType input_data_; + std::vector expected_output_; + + protected: + void SetUp() override { + size_t n = 400; + + size_t size = n * n; + + std::vector a(size); + std::vector b(size); + + for (size_t i = 0; i < size; ++i) { + a[i] = static_cast(i + 1); + } + + for (size_t i = 0; i < size; ++i) { + b[i] = static_cast(size - i); + } + + input_data_ = std::make_tuple(n, a, b); + + std::vector expected(size, 0.0); + ReferenceMultiply(a, b, expected, n); + expected_output_ = expected; + } + + bool CheckTestOutputData(OutType &output_data) final { + const auto &expected = expected_output_; + const auto &actual = output_data; + + if (expected.size() != actual.size()) { + return false; + } + + + const double epsilon = 1e-7; + for (size_t i = 0; i < expected.size(); ++i) { + if (std::abs(expected[i] - actual[i]) > epsilon) { + return false; + } + } + return true; + } + + static void ReferenceMultiply(const std::vector &a, + const std::vector &b, + std::vector &c, + size_t n) { + for (size_t i = 0; i < n; ++i) { + for (size_t k = 0; k < n; ++k) { + double tmp = a[(i * n) + k]; + for (size_t j = 0; j < n; ++j) { + c[(i * n) + j] += tmp * b[(k * n) + j]; + } + } + } + } + + InType GetTestInputData() final { + return input_data_; + } +}; + +TEST_P(MatmulDoublePerfTest, RunPerfModes) { + ExecuteTest(GetParam()); +} + +namespace { + +const auto kAllPerfTasks = + ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); + +const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); + +const auto kPerfTestName = MatmulDoublePerfTest::CustomPerfTestName; + +INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerfTest, kGtestValues, kPerfTestName); + +} // namespace + +} // namespace makoveeva_matmul_double_seq \ No newline at end of file From 273c8cf66820415e2a54061064370c9c0b9ca899 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Tue, 24 Feb 2026 22:44:58 +0300 Subject: [PATCH 02/18] commit with seq --- .../common/include/common.hpp | 4 +- .../seq/include/ops_seq.hpp | 18 +++++---- .../seq/src/ops_seq.cpp | 37 ++++++++++--------- .../tests/functional/main.cpp | 32 +++++++--------- .../tests/performance/main.cpp | 17 +++------ 5 files changed, 52 insertions(+), 56 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp index 3ff1691a..b02a6c4a 100644 --- a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp +++ b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp @@ -10,8 +10,8 @@ namespace makoveeva_matmul_double_seq { using InType = std::tuple, std::vector>; -using OutType = std::vector; +using OutType = std::vector; using TestType = std::tuple; using BaseTask = ppc::task::Task; -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp index 323989d3..5d24bbf1 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp +++ b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp @@ -12,21 +12,23 @@ class MatmulDoubleSeqTask : public BaseTask { static constexpr ppc::task::TypeOfTask GetStaticTypeOfTask() { return ppc::task::TypeOfTask::kSEQ; } - + explicit MatmulDoubleSeqTask(const InType &in); - + bool ValidationImpl() override; bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - - const std::vector& GetResult() const { return C_; } + + const std::vector &GetResult() const { + return C_; + } private: - size_t n_; + size_t n_; std::vector A_; - std::vector B_; - std::vector C_; + std::vector B_; + std::vector C_; }; -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 81dd89d1..7203ae63 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -7,21 +7,24 @@ namespace makoveeva_matmul_double_seq { MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) { SetTypeOfTask(GetStaticTypeOfTask()); - + n_ = std::get<0>(in); A_ = std::get<1>(in); B_ = std::get<2>(in); - + C_.assign(n_ * n_, 0.0); - GetOutput() = C_; + GetOutput() = C_; } bool MatmulDoubleSeqTask::ValidationImpl() { + if (n_ <= 0) { + return false; + } + + if (A_.size() != n_ * n_ || B_.size() != n_ * n_) { + return false; + } - if (n_ <= 0) return false; - - if (A_.size() != n_ * n_ || B_.size() != n_ * n_) return false; - return true; } @@ -30,15 +33,15 @@ bool MatmulDoubleSeqTask::PreProcessingImpl() { } bool MatmulDoubleSeqTask::RunImpl() { - if (n_ <= 0) return false; - - + if (n_ <= 0) { + return false; + } + int block_size = std::max(1, static_cast(std::sqrt(n_))); int num_blocks = (n_ + block_size - 1) / block_size; - - + C_.assign(n_ * n_, 0.0); - + for (int ib = 0; ib < num_blocks; ib++) { for (int jb = 0; jb < num_blocks; jb++) { for (int kb = 0; kb < num_blocks; kb++) { @@ -48,7 +51,7 @@ bool MatmulDoubleSeqTask::RunImpl() { int j_end = std::min(j_start + block_size, static_cast(n_)); int k_start = kb * block_size; int k_end = std::min(k_start + block_size, static_cast(n_)); - + for (int i = i_start; i < i_end; i++) { for (int j = j_start; j < j_end; j++) { double sum = 0.0; @@ -61,9 +64,9 @@ bool MatmulDoubleSeqTask::RunImpl() { } } } - + GetOutput() = C_; - + return true; } @@ -71,4 +74,4 @@ bool MatmulDoubleSeqTask::PostProcessingImpl() { return true; } -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index d4bfcc23..a13c4c40 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -1,17 +1,15 @@ #include -#include #include #include +#include #include "makoveeva_matmul_double_seq/common/include/common.hpp" #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" namespace makoveeva_matmul_double_seq { -std::vector SimpleMultiply(const std::vector& A, - const std::vector& B, - size_t n) { +std::vector SimpleMultiply(const std::vector &A, const std::vector &B, size_t n) { std::vector C(n * n, 0.0); for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { @@ -25,26 +23,24 @@ std::vector SimpleMultiply(const std::vector& A, return C; } - TEST(MatmulDoubleTest, Test2x2) { size_t n = 2; - std::vector A = {1.0, 2.0, 3.0, 4.0}; std::vector B = {5.0, 6.0, 7.0, 8.0}; std::vector expected = {19.0, 22.0, 43.0, 50.0}; - + auto input = std::make_tuple(n, A, B); MatmulDoubleSeqTask task(input); - + ASSERT_TRUE(task.ValidationImpl()); ASSERT_TRUE(task.PreProcessingImpl()); ASSERT_TRUE(task.RunImpl()); ASSERT_TRUE(task.PostProcessingImpl()); - + auto result = task.GetResult(); - + for (size_t i = 0; i < result.size(); i++) { EXPECT_NEAR(result[i], expected[i], 1e-10); } @@ -52,34 +48,34 @@ TEST(MatmulDoubleTest, Test2x2) { TEST(MatmulDoubleTest, TestVariousSizes) { std::vector sizes = {2, 3, 4, 5, 8}; - + for (size_t n : sizes) { std::vector A(n * n); std::vector B(n * n); - + for (size_t i = 0; i < n; i++) { for (size_t j = 0; j < n; j++) { A[i * n + j] = static_cast(i + j + 1); B[i * n + j] = static_cast(i * n + j + 1); } } - + auto expected = SimpleMultiply(A, B, n); auto input = std::make_tuple(n, A, B); - + MatmulDoubleSeqTask task(input); - + ASSERT_TRUE(task.ValidationImpl()) << "Failed validation for n=" << n; ASSERT_TRUE(task.PreProcessingImpl()) << "Failed preprocessing for n=" << n; ASSERT_TRUE(task.RunImpl()) << "Failed run for n=" << n; ASSERT_TRUE(task.PostProcessingImpl()) << "Failed postprocessing for n=" << n; - + auto result = task.GetResult(); - + for (size_t i = 0; i < result.size(); i++) { EXPECT_NEAR(result[i], expected[i], 1e-10) << "Failed at index " << i << " for n=" << n; } } } -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 59afb51d..9238a17d 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -18,7 +18,7 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests protected: void SetUp() override { size_t n = 400; - + size_t size = n * n; std::vector a(size); @@ -47,7 +47,6 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests return false; } - const double epsilon = 1e-7; for (size_t i = 0; i < expected.size(); ++i) { if (std::abs(expected[i] - actual[i]) > epsilon) { @@ -57,9 +56,7 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests return true; } - static void ReferenceMultiply(const std::vector &a, - const std::vector &b, - std::vector &c, + static void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { @@ -82,11 +79,9 @@ TEST_P(MatmulDoublePerfTest, RunPerfModes) { namespace { -const auto kAllPerfTasks = - ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); +const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); @@ -96,4 +91,4 @@ INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerfTest, kGtestValues, kPerf } // namespace -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq From bedafc5ea81cea9bf77276016e61926925473ac1 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Tue, 24 Feb 2026 23:15:41 +0300 Subject: [PATCH 03/18] 3 commit with seq --- .../seq/include/ops_seq.hpp | 3 +- .../seq/src/ops_seq.cpp | 43 ++++++------------- .../tests/functional/main.cpp | 5 ++- 3 files changed, 20 insertions(+), 31 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp index 5d24bbf1..91d7d8c6 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp +++ b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp @@ -1,5 +1,6 @@ #pragma once +#include #include #include "makoveeva_matmul_double_seq/common/include/common.hpp" @@ -20,7 +21,7 @@ class MatmulDoubleSeqTask : public BaseTask { bool RunImpl() override; bool PostProcessingImpl() override; - const std::vector &GetResult() const { + [[nodiscard]] const std::vector &GetResult() const { return C_; } diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 7203ae63..b86f01be 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -1,31 +1,19 @@ #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" +#include #include #include namespace makoveeva_matmul_double_seq { -MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) { +MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) + : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { SetTypeOfTask(GetStaticTypeOfTask()); - - n_ = std::get<0>(in); - A_ = std::get<1>(in); - B_ = std::get<2>(in); - - C_.assign(n_ * n_, 0.0); GetOutput() = C_; } bool MatmulDoubleSeqTask::ValidationImpl() { - if (n_ <= 0) { - return false; - } - - if (A_.size() != n_ * n_ || B_.size() != n_ * n_) { - return false; - } - - return true; + return n_ > 0 && A_.size() == n_ * n_ && B_.size() == n_ * n_; } bool MatmulDoubleSeqTask::PreProcessingImpl() { @@ -37,14 +25,12 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } - int block_size = std::max(1, static_cast(std::sqrt(n_))); - int num_blocks = (n_ + block_size - 1) / block_size; - - C_.assign(n_ * n_, 0.0); + int block_size = std::max(1, static_cast(std::sqrt(static_cast(n_)))); + int num_blocks = static_cast((n_ + block_size - 1) / block_size); - for (int ib = 0; ib < num_blocks; ib++) { - for (int jb = 0; jb < num_blocks; jb++) { - for (int kb = 0; kb < num_blocks; kb++) { + for (int ib = 0; ib < num_blocks; ++ib) { + for (int jb = 0; jb < num_blocks; ++jb) { + for (int kb = 0; kb < num_blocks; ++kb) { int i_start = ib * block_size; int i_end = std::min(i_start + block_size, static_cast(n_)); int j_start = jb * block_size; @@ -52,13 +38,13 @@ bool MatmulDoubleSeqTask::RunImpl() { int k_start = kb * block_size; int k_end = std::min(k_start + block_size, static_cast(n_)); - for (int i = i_start; i < i_end; i++) { - for (int j = j_start; j < j_end; j++) { + for (int i = i_start; i < i_end; ++i) { + for (int j = j_start; j < j_end; ++j) { double sum = 0.0; - for (int k = k_start; k < k_end; k++) { - sum += A_[i * n_ + k] * B_[k * n_ + j]; + for (int k = k_start; k < k_end; ++k) { + sum += A_[(i * n_) + k] * B_[(k * n_) + j]; } - C_[i * n_ + j] += sum; + C_[(i * n_) + j] += sum; } } } @@ -66,7 +52,6 @@ bool MatmulDoubleSeqTask::RunImpl() { } GetOutput() = C_; - return true; } diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index a13c4c40..fea5a889 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -9,6 +9,8 @@ namespace makoveeva_matmul_double_seq { +namespace { + std::vector SimpleMultiply(const std::vector &A, const std::vector &B, size_t n) { std::vector C(n * n, 0.0); for (size_t i = 0; i < n; i++) { @@ -23,11 +25,12 @@ std::vector SimpleMultiply(const std::vector &A, const std::vect return C; } +} // namespace + TEST(MatmulDoubleTest, Test2x2) { size_t n = 2; std::vector A = {1.0, 2.0, 3.0, 4.0}; - std::vector B = {5.0, 6.0, 7.0, 8.0}; std::vector expected = {19.0, 22.0, 43.0, 50.0}; From f7ba1598317d3e3ad2ac3adfe05b8ae94fdee873 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 22:20:38 +0300 Subject: [PATCH 04/18] tidy --- tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp | 2 ++ 1 file changed, 2 insertions(+) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index b86f01be..6c6f9da4 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -4,6 +4,8 @@ #include #include +#include "makoveeva_matmul_double_seq/common/include/common.hpp" + namespace makoveeva_matmul_double_seq { MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) From a46f454a18fd1dc1ce57a9db2a3ad1dd5f06153a Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 22:34:52 +0300 Subject: [PATCH 05/18] tidy2 --- .../seq/src/ops_seq.cpp | 37 +++++++++------ .../tests/functional/main.cpp | 47 +++++++++---------- .../tests/performance/main.cpp | 8 ++-- 3 files changed, 48 insertions(+), 44 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 6c6f9da4..a46489d1 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -4,9 +4,23 @@ #include #include -#include "makoveeva_matmul_double_seq/common/include/common.hpp" - namespace makoveeva_matmul_double_seq { +namespace { + +void MultiplyBlocks(const std::vector &a, const std::vector &b, std::vector &c, int n, + int i_start, int i_end, int j_start, int j_end, int k_start, int k_end) { + for (int i = i_start; i < i_end; ++i) { + for (int j = j_start; j < j_end; ++j) { + double sum = 0.0; + for (int k = k_start; k < k_end; ++k) { + sum += a[(i * n) + k] * b[(k * n) + j]; + } + c[(i * n) + j] += sum; + } + } +} + +} // namespace MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { @@ -27,28 +41,21 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } + int n_int = static_cast(n_); int block_size = std::max(1, static_cast(std::sqrt(static_cast(n_)))); - int num_blocks = static_cast((n_ + block_size - 1) / block_size); + int num_blocks = (n_int + block_size - 1) / block_size; for (int ib = 0; ib < num_blocks; ++ib) { for (int jb = 0; jb < num_blocks; ++jb) { for (int kb = 0; kb < num_blocks; ++kb) { int i_start = ib * block_size; - int i_end = std::min(i_start + block_size, static_cast(n_)); + int i_end = std::min(i_start + block_size, n_int); int j_start = jb * block_size; - int j_end = std::min(j_start + block_size, static_cast(n_)); + int j_end = std::min(j_start + block_size, n_int); int k_start = kb * block_size; - int k_end = std::min(k_start + block_size, static_cast(n_)); + int k_end = std::min(k_start + block_size, n_int); - for (int i = i_start; i < i_end; ++i) { - for (int j = j_start; j < j_end; ++j) { - double sum = 0.0; - for (int k = k_start; k < k_end; ++k) { - sum += A_[(i * n_) + k] * B_[(k * n_) + j]; - } - C_[(i * n_) + j] += sum; - } - } + MultiplyBlocks(A_, B_, C_, n_int, i_start, i_end, j_start, j_end, k_start, k_end); } } } diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index fea5a889..a2cbd15d 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -8,33 +8,32 @@ #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" namespace makoveeva_matmul_double_seq { - namespace { -std::vector SimpleMultiply(const std::vector &A, const std::vector &B, size_t n) { - std::vector C(n * n, 0.0); - for (size_t i = 0; i < n; i++) { - for (size_t j = 0; j < n; j++) { +std::vector SimpleMultiply(const std::vector &a, const std::vector &b, size_t n) { + std::vector c(n * n, 0.0); + for (size_t i = 0; i < n; ++i) { + for (size_t j = 0; j < n; ++j) { double sum = 0.0; - for (size_t k = 0; k < n; k++) { - sum += A[i * n + k] * B[k * n + j]; + for (size_t k = 0; k < n; ++k) { + sum += a[(i * n) + k] * b[(k * n) + j]; } - C[i * n + j] = sum; + c[(i * n) + j] = sum; } } - return C; + return c; } } // namespace -TEST(MatmulDoubleTest, Test2x2) { +TEST(MatmulDoubleTest, Test2x2) { // NOLINT size_t n = 2; - std::vector A = {1.0, 2.0, 3.0, 4.0}; - std::vector B = {5.0, 6.0, 7.0, 8.0}; + std::vector a = {1.0, 2.0, 3.0, 4.0}; + std::vector b = {5.0, 6.0, 7.0, 8.0}; std::vector expected = {19.0, 22.0, 43.0, 50.0}; - auto input = std::make_tuple(n, A, B); + auto input = std::make_tuple(n, a, b); MatmulDoubleSeqTask task(input); ASSERT_TRUE(task.ValidationImpl()); @@ -44,27 +43,27 @@ TEST(MatmulDoubleTest, Test2x2) { auto result = task.GetResult(); - for (size_t i = 0; i < result.size(); i++) { + for (size_t i = 0; i < result.size(); ++i) { EXPECT_NEAR(result[i], expected[i], 1e-10); } } -TEST(MatmulDoubleTest, TestVariousSizes) { +TEST(MatmulDoubleTest, TestVariousSizes) { // NOLINT std::vector sizes = {2, 3, 4, 5, 8}; for (size_t n : sizes) { - std::vector A(n * n); - std::vector B(n * n); + std::vector a(n * n); + std::vector b(n * n); - for (size_t i = 0; i < n; i++) { - for (size_t j = 0; j < n; j++) { - A[i * n + j] = static_cast(i + j + 1); - B[i * n + j] = static_cast(i * n + j + 1); + for (size_t i = 0; i < n; ++i) { + for (size_t j = 0; j < n; ++j) { + a[(i * n) + j] = static_cast(i + j + 1); + b[(i * n) + j] = static_cast((i * n) + j + 1); } } - auto expected = SimpleMultiply(A, B, n); - auto input = std::make_tuple(n, A, B); + auto expected = SimpleMultiply(a, b, n); + auto input = std::make_tuple(n, a, b); MatmulDoubleSeqTask task(input); @@ -75,7 +74,7 @@ TEST(MatmulDoubleTest, TestVariousSizes) { auto result = task.GetResult(); - for (size_t i = 0; i < result.size(); i++) { + for (size_t i = 0; i < result.size(); ++i) { EXPECT_NEAR(result[i], expected[i], 1e-10) << "Failed at index " << i << " for n=" << n; } } diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 9238a17d..571ec714 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -18,7 +18,6 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests protected: void SetUp() override { size_t n = 400; - size_t size = n * n; std::vector a(size); @@ -73,15 +72,14 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests } }; -TEST_P(MatmulDoublePerfTest, RunPerfModes) { +TEST_P(MatmulDoublePerfTest, RunPerfModes) { // NOLINT ExecuteTest(GetParam()); } namespace { -const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); +const auto kAllPerfTasks = + ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); From a8aa01822e6d2150d04c2c12229d31263745aec1 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 22:38:58 +0300 Subject: [PATCH 06/18] tidy3 --- .../common/include/common.hpp | 2 +- .../seq/include/ops_seq.hpp | 8 +- .../seq/src/ops_seq.cpp | 60 +++++++--- .../tests/functional/main.cpp | 104 ++++++++++++------ .../tests/performance/main.cpp | 44 ++++---- 5 files changed, 140 insertions(+), 78 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp index b02a6c4a..b2730eac 100644 --- a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp +++ b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp @@ -14,4 +14,4 @@ using OutType = std::vector; using TestType = std::tuple; using BaseTask = ppc::task::Task; -} // namespace makoveeva_matmul_double_seq +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp index 91d7d8c6..e7ccbe15 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp +++ b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp @@ -14,16 +14,14 @@ class MatmulDoubleSeqTask : public BaseTask { return ppc::task::TypeOfTask::kSEQ; } - explicit MatmulDoubleSeqTask(const InType &in); + explicit MatmulDoubleSeqTask(const InType& in); bool ValidationImpl() override; bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - [[nodiscard]] const std::vector &GetResult() const { - return C_; - } + [[nodiscard]] const std::vector& GetResult() const { return C_; } private: size_t n_; @@ -32,4 +30,4 @@ class MatmulDoubleSeqTask : public BaseTask { std::vector C_; }; -} // namespace makoveeva_matmul_double_seq +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index a46489d1..aa0a72d6 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -2,13 +2,22 @@ #include #include +#include #include namespace makoveeva_matmul_double_seq { namespace { -void MultiplyBlocks(const std::vector &a, const std::vector &b, std::vector &c, int n, - int i_start, int i_end, int j_start, int j_end, int k_start, int k_end) { +void ProcessBlock(const std::vector& a, + const std::vector& b, + std::vector& c, + int n, + int i_start, + int i_end, + int j_start, + int j_end, + int k_start, + int k_end) { for (int i = i_start; i < i_end; ++i) { for (int j = j_start; j < j_end; ++j) { double sum = 0.0; @@ -20,16 +29,30 @@ void MultiplyBlocks(const std::vector &a, const std::vector &b, } } +int CalculateBlockSize(int n) { + return std::max(1, static_cast(std::sqrt(static_cast(n)))); +} + +int CalculateNumBlocks(int n, int block_size) { + return (n + block_size - 1) / block_size; +} + } // namespace -MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) - : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { +MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType& in) + : n_(std::get<0>(in)), + A_(std::get<1>(in)), + B_(std::get<2>(in)), + C_(n_ * n_, 0.0) { SetTypeOfTask(GetStaticTypeOfTask()); GetOutput() = C_; } bool MatmulDoubleSeqTask::ValidationImpl() { - return n_ > 0 && A_.size() == n_ * n_ && B_.size() == n_ * n_; + const bool valid_n = n_ > 0; + const bool valid_a = A_.size() == n_ * n_; + const bool valid_b = B_.size() == n_ * n_; + return valid_n && valid_a && valid_b; } bool MatmulDoubleSeqTask::PreProcessingImpl() { @@ -41,21 +64,24 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } - int n_int = static_cast(n_); - int block_size = std::max(1, static_cast(std::sqrt(static_cast(n_)))); - int num_blocks = (n_int + block_size - 1) / block_size; + const int n_int = static_cast(n_); + const int block_size = CalculateBlockSize(n_int); + const int num_blocks = CalculateNumBlocks(n_int, block_size); for (int ib = 0; ib < num_blocks; ++ib) { for (int jb = 0; jb < num_blocks; ++jb) { for (int kb = 0; kb < num_blocks; ++kb) { - int i_start = ib * block_size; - int i_end = std::min(i_start + block_size, n_int); - int j_start = jb * block_size; - int j_end = std::min(j_start + block_size, n_int); - int k_start = kb * block_size; - int k_end = std::min(k_start + block_size, n_int); - - MultiplyBlocks(A_, B_, C_, n_int, i_start, i_end, j_start, j_end, k_start, k_end); + const int i_start = ib * block_size; + const int i_end = std::min(i_start + block_size, n_int); + const int j_start = jb * block_size; + const int j_end = std::min(j_start + block_size, n_int); + const int k_start = kb * block_size; + const int k_end = std::min(k_start + block_size, n_int); + + ProcessBlock(A_, B_, C_, n_int, + i_start, i_end, + j_start, j_end, + k_start, k_end); } } } @@ -68,4 +94,4 @@ bool MatmulDoubleSeqTask::PostProcessingImpl() { return true; } -} // namespace makoveeva_matmul_double_seq +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index a2cbd15d..2852a57e 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -1,6 +1,7 @@ #include #include +#include #include #include @@ -10,23 +11,36 @@ namespace makoveeva_matmul_double_seq { namespace { -std::vector SimpleMultiply(const std::vector &a, const std::vector &b, size_t n) { +// Эталонное умножение матриц - вынесено в отдельную функцию +std::vector ReferenceMultiply(const std::vector& a, + const std::vector& b, + size_t n) { std::vector c(n * n, 0.0); for (size_t i = 0; i < n; ++i) { - for (size_t j = 0; j < n; ++j) { - double sum = 0.0; - for (size_t k = 0; k < n; ++k) { - sum += a[(i * n) + k] * b[(k * n) + j]; + for (size_t k = 0; k < n; ++k) { + double tmp = a[(i * n) + k]; + for (size_t j = 0; j < n; ++j) { + c[(i * n) + j] += tmp * b[(k * n) + j]; } - c[(i * n) + j] = sum; } } return c; } +// Проверка результатов с допуском +void CheckResults(const std::vector& actual, + const std::vector& expected, + size_t n) { + const double epsilon = 1e-10; + for (size_t i = 0; i < n * n; ++i) { + ASSERT_NEAR(actual[i], expected[i], epsilon); + } +} + } // namespace -TEST(MatmulDoubleTest, Test2x2) { // NOLINT +// Тест для матрицы 2x2 +TEST(MatmulDoubleFunctionalTest, Multiply2x2) { size_t n = 2; std::vector a = {1.0, 2.0, 3.0, 4.0}; @@ -42,42 +56,62 @@ TEST(MatmulDoubleTest, Test2x2) { // NOLINT ASSERT_TRUE(task.PostProcessingImpl()); auto result = task.GetResult(); - - for (size_t i = 0; i < result.size(); ++i) { - EXPECT_NEAR(result[i], expected[i], 1e-10); - } + CheckResults(result, expected, n); } -TEST(MatmulDoubleTest, TestVariousSizes) { // NOLINT - std::vector sizes = {2, 3, 4, 5, 8}; +// Тест для матрицы 3x3 +TEST(MatmulDoubleFunctionalTest, Multiply3x3) { + size_t n = 3; - for (size_t n : sizes) { - std::vector a(n * n); - std::vector b(n * n); + std::vector a = {1.0, 2.0, 3.0, + 4.0, 5.0, 6.0, + 7.0, 8.0, 9.0}; - for (size_t i = 0; i < n; ++i) { - for (size_t j = 0; j < n; ++j) { - a[(i * n) + j] = static_cast(i + j + 1); - b[(i * n) + j] = static_cast((i * n) + j + 1); - } - } + std::vector b = {9.0, 8.0, 7.0, + 6.0, 5.0, 4.0, + 3.0, 2.0, 1.0}; - auto expected = SimpleMultiply(a, b, n); - auto input = std::make_tuple(n, a, b); + std::vector expected = {30.0, 24.0, 18.0, + 84.0, 69.0, 54.0, + 138.0, 114.0, 90.0}; - MatmulDoubleSeqTask task(input); + auto input = std::make_tuple(n, a, b); + MatmulDoubleSeqTask task(input); - ASSERT_TRUE(task.ValidationImpl()) << "Failed validation for n=" << n; - ASSERT_TRUE(task.PreProcessingImpl()) << "Failed preprocessing for n=" << n; - ASSERT_TRUE(task.RunImpl()) << "Failed run for n=" << n; - ASSERT_TRUE(task.PostProcessingImpl()) << "Failed postprocessing for n=" << n; + ASSERT_TRUE(task.ValidationImpl()); + ASSERT_TRUE(task.PreProcessingImpl()); + ASSERT_TRUE(task.RunImpl()); + ASSERT_TRUE(task.PostProcessingImpl()); - auto result = task.GetResult(); + auto result = task.GetResult(); + CheckResults(result, expected, n); +} - for (size_t i = 0; i < result.size(); ++i) { - EXPECT_NEAR(result[i], expected[i], 1e-10) << "Failed at index " << i << " for n=" << n; - } - } +// Тест для матрицы 4x4 +TEST(MatmulDoubleFunctionalTest, Multiply4x4) { + size_t n = 4; + + std::vector a = {1.0, 2.0, 3.0, 4.0, + 5.0, 6.0, 7.0, 8.0, + 9.0, 10.0, 11.0, 12.0, + 13.0, 14.0, 15.0, 16.0}; + + std::vector b = {16.0, 15.0, 14.0, 13.0, + 12.0, 11.0, 10.0, 9.0, + 8.0, 7.0, 6.0, 5.0, + 4.0, 3.0, 2.0, 1.0}; + + auto expected = ReferenceMultiply(a, b, n); + auto input = std::make_tuple(n, a, b); + MatmulDoubleSeqTask task(input); + + ASSERT_TRUE(task.ValidationImpl()); + ASSERT_TRUE(task.PreProcessingImpl()); + ASSERT_TRUE(task.RunImpl()); + ASSERT_TRUE(task.PostProcessingImpl()); + + auto result = task.GetResult(); + CheckResults(result, expected, n); } -} // namespace makoveeva_matmul_double_seq +} // namespace makoveeva_matmul_double_seq \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 571ec714..0086059a 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -11,36 +11,33 @@ namespace makoveeva_matmul_double_seq { -class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests { +class MatmulDoublePerformanceTest + : public ppc::util::BaseRunPerfTests { InType input_data_; std::vector expected_output_; protected: void SetUp() override { - size_t n = 400; - size_t size = n * n; + const size_t n = 400; + const size_t size = n * n; std::vector a(size); std::vector b(size); for (size_t i = 0; i < size; ++i) { a[i] = static_cast(i + 1); - } - - for (size_t i = 0; i < size; ++i) { b[i] = static_cast(size - i); } input_data_ = std::make_tuple(n, a, b); - std::vector expected(size, 0.0); - ReferenceMultiply(a, b, expected, n); - expected_output_ = expected; + expected_output_.assign(size, 0.0); + ReferenceMultiply(a, b, expected_output_, n); } - bool CheckTestOutputData(OutType &output_data) final { - const auto &expected = expected_output_; - const auto &actual = output_data; + bool CheckTestOutputData(OutType& output_data) final { + const auto& expected = expected_output_; + const auto& actual = output_data; if (expected.size() != actual.size()) { return false; @@ -55,11 +52,13 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests return true; } - static void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, + static void ReferenceMultiply(const std::vector& a, + const std::vector& b, + std::vector& c, size_t n) { for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { - double tmp = a[(i * n) + k]; + const double tmp = a[(i * n) + k]; for (size_t j = 0; j < n; ++j) { c[(i * n) + j] += tmp * b[(k * n) + j]; } @@ -72,21 +71,26 @@ class MatmulDoublePerfTest : public ppc::util::BaseRunPerfTests } }; -TEST_P(MatmulDoublePerfTest, RunPerfModes) { // NOLINT +TEST_P(MatmulDoublePerformanceTest, RunPerfModes) { ExecuteTest(GetParam()); } namespace { -const auto kAllPerfTasks = - ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); +const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks( + PPC_SETTINGS_makoveeva_matmul_double_seq); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); -const auto kPerfTestName = MatmulDoublePerfTest::CustomPerfTestName; +const auto kPerfTestName = MatmulDoublePerformanceTest::CustomPerfTestName; -INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerfTest, kGtestValues, kPerfTestName); +INSTANTIATE_TEST_SUITE_P( + RunModeTests, + MatmulDoublePerformanceTest, + kGtestValues, + kPerfTestName); } // namespace -} // namespace makoveeva_matmul_double_seq +} // namespace makoveeva_matmul_double_seq \ No newline at end of file From f0629245d05da4e930722ab441e50fa42aab9471 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 22:41:26 +0300 Subject: [PATCH 07/18] pre-commit --- .../common/include/common.hpp | 2 +- .../seq/include/ops_seq.hpp | 8 +++-- .../seq/src/ops_seq.cpp | 26 ++++----------- .../tests/functional/main.cpp | 32 +++++-------------- .../tests/performance/main.cpp | 26 ++++++--------- 5 files changed, 29 insertions(+), 65 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp index b2730eac..b02a6c4a 100644 --- a/tasks/makoveeva_matmul_double_seq/common/include/common.hpp +++ b/tasks/makoveeva_matmul_double_seq/common/include/common.hpp @@ -14,4 +14,4 @@ using OutType = std::vector; using TestType = std::tuple; using BaseTask = ppc::task::Task; -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp index e7ccbe15..91d7d8c6 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp +++ b/tasks/makoveeva_matmul_double_seq/seq/include/ops_seq.hpp @@ -14,14 +14,16 @@ class MatmulDoubleSeqTask : public BaseTask { return ppc::task::TypeOfTask::kSEQ; } - explicit MatmulDoubleSeqTask(const InType& in); + explicit MatmulDoubleSeqTask(const InType &in); bool ValidationImpl() override; bool PreProcessingImpl() override; bool RunImpl() override; bool PostProcessingImpl() override; - [[nodiscard]] const std::vector& GetResult() const { return C_; } + [[nodiscard]] const std::vector &GetResult() const { + return C_; + } private: size_t n_; @@ -30,4 +32,4 @@ class MatmulDoubleSeqTask : public BaseTask { std::vector C_; }; -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index aa0a72d6..dfe698d5 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -8,16 +8,8 @@ namespace makoveeva_matmul_double_seq { namespace { -void ProcessBlock(const std::vector& a, - const std::vector& b, - std::vector& c, - int n, - int i_start, - int i_end, - int j_start, - int j_end, - int k_start, - int k_end) { +void ProcessBlock(const std::vector &a, const std::vector &b, std::vector &c, int n, + int i_start, int i_end, int j_start, int j_end, int k_start, int k_end) { for (int i = i_start; i < i_end; ++i) { for (int j = j_start; j < j_end; ++j) { double sum = 0.0; @@ -39,11 +31,8 @@ int CalculateNumBlocks(int n, int block_size) { } // namespace -MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType& in) - : n_(std::get<0>(in)), - A_(std::get<1>(in)), - B_(std::get<2>(in)), - C_(n_ * n_, 0.0) { +MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) + : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { SetTypeOfTask(GetStaticTypeOfTask()); GetOutput() = C_; } @@ -78,10 +67,7 @@ bool MatmulDoubleSeqTask::RunImpl() { const int k_start = kb * block_size; const int k_end = std::min(k_start + block_size, n_int); - ProcessBlock(A_, B_, C_, n_int, - i_start, i_end, - j_start, j_end, - k_start, k_end); + ProcessBlock(A_, B_, C_, n_int, i_start, i_end, j_start, j_end, k_start, k_end); } } } @@ -94,4 +80,4 @@ bool MatmulDoubleSeqTask::PostProcessingImpl() { return true; } -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index 2852a57e..378a845a 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -12,9 +12,7 @@ namespace makoveeva_matmul_double_seq { namespace { // Эталонное умножение матриц - вынесено в отдельную функцию -std::vector ReferenceMultiply(const std::vector& a, - const std::vector& b, - size_t n) { +std::vector ReferenceMultiply(const std::vector &a, const std::vector &b, size_t n) { std::vector c(n * n, 0.0); for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { @@ -28,9 +26,7 @@ std::vector ReferenceMultiply(const std::vector& a, } // Проверка результатов с допуском -void CheckResults(const std::vector& actual, - const std::vector& expected, - size_t n) { +void CheckResults(const std::vector &actual, const std::vector &expected, size_t n) { const double epsilon = 1e-10; for (size_t i = 0; i < n * n; ++i) { ASSERT_NEAR(actual[i], expected[i], epsilon); @@ -63,17 +59,11 @@ TEST(MatmulDoubleFunctionalTest, Multiply2x2) { TEST(MatmulDoubleFunctionalTest, Multiply3x3) { size_t n = 3; - std::vector a = {1.0, 2.0, 3.0, - 4.0, 5.0, 6.0, - 7.0, 8.0, 9.0}; + std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; - std::vector b = {9.0, 8.0, 7.0, - 6.0, 5.0, 4.0, - 3.0, 2.0, 1.0}; + std::vector b = {9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; - std::vector expected = {30.0, 24.0, 18.0, - 84.0, 69.0, 54.0, - 138.0, 114.0, 90.0}; + std::vector expected = {30.0, 24.0, 18.0, 84.0, 69.0, 54.0, 138.0, 114.0, 90.0}; auto input = std::make_tuple(n, a, b); MatmulDoubleSeqTask task(input); @@ -91,15 +81,9 @@ TEST(MatmulDoubleFunctionalTest, Multiply3x3) { TEST(MatmulDoubleFunctionalTest, Multiply4x4) { size_t n = 4; - std::vector a = {1.0, 2.0, 3.0, 4.0, - 5.0, 6.0, 7.0, 8.0, - 9.0, 10.0, 11.0, 12.0, - 13.0, 14.0, 15.0, 16.0}; + std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0}; - std::vector b = {16.0, 15.0, 14.0, 13.0, - 12.0, 11.0, 10.0, 9.0, - 8.0, 7.0, 6.0, 5.0, - 4.0, 3.0, 2.0, 1.0}; + std::vector b = {16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; auto expected = ReferenceMultiply(a, b, n); auto input = std::make_tuple(n, a, b); @@ -114,4 +98,4 @@ TEST(MatmulDoubleFunctionalTest, Multiply4x4) { CheckResults(result, expected, n); } -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 0086059a..976db5db 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -11,8 +11,7 @@ namespace makoveeva_matmul_double_seq { -class MatmulDoublePerformanceTest - : public ppc::util::BaseRunPerfTests { +class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests { InType input_data_; std::vector expected_output_; @@ -35,9 +34,9 @@ class MatmulDoublePerformanceTest ReferenceMultiply(a, b, expected_output_, n); } - bool CheckTestOutputData(OutType& output_data) final { - const auto& expected = expected_output_; - const auto& actual = output_data; + bool CheckTestOutputData(OutType &output_data) final { + const auto &expected = expected_output_; + const auto &actual = output_data; if (expected.size() != actual.size()) { return false; @@ -52,9 +51,7 @@ class MatmulDoublePerformanceTest return true; } - static void ReferenceMultiply(const std::vector& a, - const std::vector& b, - std::vector& c, + static void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { @@ -77,20 +74,15 @@ TEST_P(MatmulDoublePerformanceTest, RunPerfModes) { namespace { -const auto kAllPerfTasks = ppc::util::MakeAllPerfTasks( - PPC_SETTINGS_makoveeva_matmul_double_seq); +const auto kAllPerfTasks = + ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); const auto kPerfTestName = MatmulDoublePerformanceTest::CustomPerfTestName; -INSTANTIATE_TEST_SUITE_P( - RunModeTests, - MatmulDoublePerformanceTest, - kGtestValues, - kPerfTestName); +INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerformanceTest, kGtestValues, kPerfTestName); } // namespace -} // namespace makoveeva_matmul_double_seq \ No newline at end of file +} // namespace makoveeva_matmul_double_seq From 3d642c5303791e17c6cede221c2ea5cdd9c91d5a Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 22:56:26 +0300 Subject: [PATCH 08/18] tidy --- .../seq/src/ops_seq.cpp | 1 - .../tests/functional/main.cpp | 94 +++++++------------ .../tests/performance/main.cpp | 1 - 3 files changed, 32 insertions(+), 64 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index dfe698d5..943a4c85 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -2,7 +2,6 @@ #include #include -#include #include namespace makoveeva_matmul_double_seq { diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index 378a845a..5fdf9e33 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -5,44 +5,24 @@ #include #include -#include "makoveeva_matmul_double_seq/common/include/common.hpp" #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" namespace makoveeva_matmul_double_seq { namespace { -// Эталонное умножение матриц - вынесено в отдельную функцию -std::vector ReferenceMultiply(const std::vector &a, const std::vector &b, size_t n) { - std::vector c(n * n, 0.0); +void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { - double tmp = a[(i * n) + k]; + const double tmp = a[(i * n) + k]; for (size_t j = 0; j < n; ++j) { c[(i * n) + j] += tmp * b[(k * n) + j]; } } } - return c; } -// Проверка результатов с допуском -void CheckResults(const std::vector &actual, const std::vector &expected, size_t n) { - const double epsilon = 1e-10; - for (size_t i = 0; i < n * n; ++i) { - ASSERT_NEAR(actual[i], expected[i], epsilon); - } -} - -} // namespace - -// Тест для матрицы 2x2 -TEST(MatmulDoubleFunctionalTest, Multiply2x2) { - size_t n = 2; - - std::vector a = {1.0, 2.0, 3.0, 4.0}; - std::vector b = {5.0, 6.0, 7.0, 8.0}; - std::vector expected = {19.0, 22.0, 43.0, 50.0}; - +void RunMatrixTest(size_t n, const std::vector &a, const std::vector &b, + const std::vector &expected) { auto input = std::make_tuple(n, a, b); MatmulDoubleSeqTask task(input); @@ -51,51 +31,41 @@ TEST(MatmulDoubleFunctionalTest, Multiply2x2) { ASSERT_TRUE(task.RunImpl()); ASSERT_TRUE(task.PostProcessingImpl()); - auto result = task.GetResult(); - CheckResults(result, expected, n); -} + const auto result = task.GetResult(); + ASSERT_EQ(result.size(), expected.size()); -// Тест для матрицы 3x3 -TEST(MatmulDoubleFunctionalTest, Multiply3x3) { - size_t n = 3; - - std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; - - std::vector b = {9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; - - std::vector expected = {30.0, 24.0, 18.0, 84.0, 69.0, 54.0, 138.0, 114.0, 90.0}; - - auto input = std::make_tuple(n, a, b); - MatmulDoubleSeqTask task(input); - - ASSERT_TRUE(task.ValidationImpl()); - ASSERT_TRUE(task.PreProcessingImpl()); - ASSERT_TRUE(task.RunImpl()); - ASSERT_TRUE(task.PostProcessingImpl()); - - auto result = task.GetResult(); - CheckResults(result, expected, n); + const double epsilon = 1e-10; + for (size_t i = 0; i < result.size(); ++i) { + ASSERT_NEAR(result[i], expected[i], epsilon); + } } -// Тест для матрицы 4x4 -TEST(MatmulDoubleFunctionalTest, Multiply4x4) { - size_t n = 4; - - std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0}; +} // namespace - std::vector b = {16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; +TEST(MatmulDoubleFunctionalTest, multiply_2x2) { + const size_t n = 2; + const std::vector a = {1.0, 2.0, 3.0, 4.0}; + const std::vector b = {5.0, 6.0, 7.0, 8.0}; + const std::vector expected = {19.0, 22.0, 43.0, 50.0}; + RunMatrixTest(n, a, b, expected); +} - auto expected = ReferenceMultiply(a, b, n); - auto input = std::make_tuple(n, a, b); - MatmulDoubleSeqTask task(input); +TEST(MatmulDoubleFunctionalTest, multiply_3x3) { + const size_t n = 3; + const std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; + const std::vector b = {9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; + const std::vector expected = {30.0, 24.0, 18.0, 84.0, 69.0, 54.0, 138.0, 114.0, 90.0}; + RunMatrixTest(n, a, b, expected); +} - ASSERT_TRUE(task.ValidationImpl()); - ASSERT_TRUE(task.PreProcessingImpl()); - ASSERT_TRUE(task.RunImpl()); - ASSERT_TRUE(task.PostProcessingImpl()); +TEST(MatmulDoubleFunctionalTest, multiply_4x4) { + const size_t n = 4; + const std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0}; + const std::vector b = {16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; - auto result = task.GetResult(); - CheckResults(result, expected, n); + std::vector expected(n * n, 0.0); + ReferenceMultiply(a, b, expected, n); + RunMatrixTest(n, a, b, expected); } } // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 976db5db..44de6452 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -5,7 +5,6 @@ #include #include -#include "makoveeva_matmul_double_seq/common/include/common.hpp" #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" #include "util/include/perf_test_util.hpp" From 8430fcc096dc7154a6e4a0045ccf7ab33292f214 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 23:16:27 +0300 Subject: [PATCH 09/18] tidy2 --- .../tests/functional/main.cpp | 37 ++++++++++++------- .../tests/performance/main.cpp | 1 + 2 files changed, 25 insertions(+), 13 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index 5fdf9e33..15f34e8f 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -21,19 +21,15 @@ void ReferenceMultiply(const std::vector &a, const std::vector & } } -void RunMatrixTest(size_t n, const std::vector &a, const std::vector &b, - const std::vector &expected) { - auto input = std::make_tuple(n, a, b); - MatmulDoubleSeqTask task(input); - +void CheckTaskExecution(MatmulDoubleSeqTask &task) { ASSERT_TRUE(task.ValidationImpl()); ASSERT_TRUE(task.PreProcessingImpl()); ASSERT_TRUE(task.RunImpl()); ASSERT_TRUE(task.PostProcessingImpl()); +} - const auto result = task.GetResult(); +void CheckResults(const std::vector &result, const std::vector &expected) { ASSERT_EQ(result.size(), expected.size()); - const double epsilon = 1e-10; for (size_t i = 0; i < result.size(); ++i) { ASSERT_NEAR(result[i], expected[i], epsilon); @@ -42,30 +38,45 @@ void RunMatrixTest(size_t n, const std::vector &a, const std::vector a = {1.0, 2.0, 3.0, 4.0}; const std::vector b = {5.0, 6.0, 7.0, 8.0}; const std::vector expected = {19.0, 22.0, 43.0, 50.0}; - RunMatrixTest(n, a, b, expected); + + auto input = std::make_tuple(n, a, b); + MatmulDoubleSeqTask task(input); + + CheckTaskExecution(task); + CheckResults(task.GetResult(), expected); } -TEST(MatmulDoubleFunctionalTest, multiply_3x3) { +TEST(MatmulDoubleFunctionalTest, multiply3x3) { const size_t n = 3; const std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0}; const std::vector b = {9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; const std::vector expected = {30.0, 24.0, 18.0, 84.0, 69.0, 54.0, 138.0, 114.0, 90.0}; - RunMatrixTest(n, a, b, expected); + + auto input = std::make_tuple(n, a, b); + MatmulDoubleSeqTask task(input); + + CheckTaskExecution(task); + CheckResults(task.GetResult(), expected); } -TEST(MatmulDoubleFunctionalTest, multiply_4x4) { +TEST(MatmulDoubleFunctionalTest, multiply4x4) { const size_t n = 4; const std::vector a = {1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0, 11.0, 12.0, 13.0, 14.0, 15.0, 16.0}; const std::vector b = {16.0, 15.0, 14.0, 13.0, 12.0, 11.0, 10.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0}; std::vector expected(n * n, 0.0); ReferenceMultiply(a, b, expected, n); - RunMatrixTest(n, a, b, expected); + + auto input = std::make_tuple(n, a, b); + MatmulDoubleSeqTask task(input); + + CheckTaskExecution(task); + CheckResults(task.GetResult(), expected); } } // namespace makoveeva_matmul_double_seq diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 44de6452..976db5db 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -5,6 +5,7 @@ #include #include +#include "makoveeva_matmul_double_seq/common/include/common.hpp" #include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" #include "util/include/perf_test_util.hpp" From 67da397ae12f71a65fef86f4d33b84bd8cb328bf Mon Sep 17 00:00:00 2001 From: sofaprog Date: Wed, 25 Feb 2026 23:32:50 +0300 Subject: [PATCH 10/18] tidy3 --- .../seq/src/ops_seq.cpp | 3 +++ .../tests/functional/main.cpp | 19 ++++++++++++++++++- 2 files changed, 21 insertions(+), 1 deletion(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 943a4c85..96757bb3 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -4,6 +4,9 @@ #include #include +// Явный include для InType, хотя он уже есть в ops_seq.hpp +#include "makoveeva_matmul_double_seq/common/include/common.hpp" + namespace makoveeva_matmul_double_seq { namespace { diff --git a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp index 15f34e8f..36f893a6 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/functional/main.cpp @@ -21,13 +21,30 @@ void ReferenceMultiply(const std::vector &a, const std::vector & } } -void CheckTaskExecution(MatmulDoubleSeqTask &task) { +// Разбиваем функцию на еще более мелкие части +void ValidateTask(MatmulDoubleSeqTask &task) { ASSERT_TRUE(task.ValidationImpl()); +} + +void PreProcessTask(MatmulDoubleSeqTask &task) { ASSERT_TRUE(task.PreProcessingImpl()); +} + +void RunTask(MatmulDoubleSeqTask &task) { ASSERT_TRUE(task.RunImpl()); +} + +void PostProcessTask(MatmulDoubleSeqTask &task) { ASSERT_TRUE(task.PostProcessingImpl()); } +void CheckTaskExecution(MatmulDoubleSeqTask &task) { + ValidateTask(task); + PreProcessTask(task); + RunTask(task); + PostProcessTask(task); +} + void CheckResults(const std::vector &result, const std::vector &expected) { ASSERT_EQ(result.size(), expected.size()); const double epsilon = 1e-10; From 838ae462d265b231e7832382a27a0b822a756728 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 21:34:07 +0300 Subject: [PATCH 11/18] fix perfomance tests --- .../seq/src/ops_seq.cpp | 4 ++ .../tests/performance/main.cpp | 37 ++++++++++++------- 2 files changed, 28 insertions(+), 13 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 96757bb3..c7c82b96 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -55,6 +55,9 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } + // Очищаем C_ перед вычислениями + std::fill(C_.begin(), C_.end(), 0.0); + const int n_int = static_cast(n_); const int block_size = CalculateBlockSize(n_int); const int num_blocks = CalculateNumBlocks(n_int, block_size); @@ -74,6 +77,7 @@ bool MatmulDoubleSeqTask::RunImpl() { } } + // Убедись, что GetOutput() получает C_ GetOutput() = C_; return true; } diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 976db5db..b132392f 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -11,6 +11,20 @@ namespace makoveeva_matmul_double_seq { +void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { + // Обнуляем c перед вычислениями + std::fill(c.begin(), c.end(), 0.0); + + for (size_t i = 0; i < n; ++i) { + for (size_t k = 0; k < n; ++k) { + const double tmp = a[(i * n) + k]; + for (size_t j = 0; j < n; ++j) { + c[(i * n) + j] += tmp * b[(k * n) + j]; + } + } + } +} + class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests { InType input_data_; std::vector expected_output_; @@ -23,6 +37,7 @@ class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests a(size); std::vector b(size); + // Заполняем матрицы for (size_t i = 0; i < size; ++i) { a[i] = static_cast(i + 1); b[i] = static_cast(size - i); @@ -30,7 +45,8 @@ class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests epsilon) { + // Для отладки выведем первые несколько несовпадений + if (i < 10) { + std::cout << "Mismatch at index " << i << ": expected=" << expected[i] << ", actual=" << actual[i] + << std::endl; + } return false; } } return true; } - static void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, - size_t n) { - for (size_t i = 0; i < n; ++i) { - for (size_t k = 0; k < n; ++k) { - const double tmp = a[(i * n) + k]; - for (size_t j = 0; j < n; ++j) { - c[(i * n) + j] += tmp * b[(k * n) + j]; - } - } - } - } - InType GetTestInputData() final { return input_data_; } From e3ff00023d982e60950ed67a4aafce4a4804b29e Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:16:54 +0300 Subject: [PATCH 12/18] fix perfomance tests2 --- .../seq/src/ops_seq.cpp | 2 -- .../tests/performance/main.cpp | 15 ++++----------- 2 files changed, 4 insertions(+), 13 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index c7c82b96..2643277a 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -4,7 +4,6 @@ #include #include -// Явный include для InType, хотя он уже есть в ops_seq.hpp #include "makoveeva_matmul_double_seq/common/include/common.hpp" namespace makoveeva_matmul_double_seq { @@ -77,7 +76,6 @@ bool MatmulDoubleSeqTask::RunImpl() { } } - // Убедись, что GetOutput() получает C_ GetOutput() = C_; return true; } diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index b132392f..b2fa0bed 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -1,5 +1,6 @@ #include +#include #include #include #include @@ -10,11 +11,10 @@ #include "util/include/perf_test_util.hpp" namespace makoveeva_matmul_double_seq { +namespace { void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { - // Обнуляем c перед вычислениями std::fill(c.begin(), c.end(), 0.0); - for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { const double tmp = a[(i * n) + k]; @@ -25,6 +25,8 @@ void ReferenceMultiply(const std::vector &a, const std::vector & } } +} // namespace + class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests { InType input_data_; std::vector expected_output_; @@ -37,7 +39,6 @@ class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests a(size); std::vector b(size); - // Заполняем матрицы for (size_t i = 0; i < size; ++i) { a[i] = static_cast(i + 1); b[i] = static_cast(size - i); @@ -45,7 +46,6 @@ class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests epsilon) { - // Для отладки выведем первые несколько несовпадений - if (i < 10) { - std::cout << "Mismatch at index " << i << ": expected=" << expected[i] << ", actual=" << actual[i] - << std::endl; - } return false; } } From e10f2ca901a8cc3fd708d174a4373fc73e64e77c Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:27:38 +0300 Subject: [PATCH 13/18] tidy!!! --- .../seq/src/ops_seq.cpp | 70 ++------------- .../tests/performance/main.cpp | 90 +++---------------- 2 files changed, 19 insertions(+), 141 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 2643277a..77c94089 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -1,61 +1,12 @@ -#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" - -#include -#include -#include - -#include "makoveeva_matmul_double_seq/common/include/common.hpp" - -namespace makoveeva_matmul_double_seq { -namespace { - -void ProcessBlock(const std::vector &a, const std::vector &b, std::vector &c, int n, - int i_start, int i_end, int j_start, int j_end, int k_start, int k_end) { - for (int i = i_start; i < i_end; ++i) { - for (int j = j_start; j < j_end; ++j) { - double sum = 0.0; - for (int k = k_start; k < k_end; ++k) { - sum += a[(i * n) + k] * b[(k * n) + j]; - } - c[(i * n) + j] += sum; - } - } -} - -int CalculateBlockSize(int n) { - return std::max(1, static_cast(std::sqrt(static_cast(n)))); -} - -int CalculateNumBlocks(int n, int block_size) { - return (n + block_size - 1) / block_size; -} - -} // namespace - -MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) - : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { - SetTypeOfTask(GetStaticTypeOfTask()); - GetOutput() = C_; -} - -bool MatmulDoubleSeqTask::ValidationImpl() { - const bool valid_n = n_ > 0; - const bool valid_a = A_.size() == n_ * n_; - const bool valid_b = B_.size() == n_ * n_; - return valid_n && valid_a && valid_b; -} - -bool MatmulDoubleSeqTask::PreProcessingImpl() { - return true; -} - bool MatmulDoubleSeqTask::RunImpl() { if (n_ <= 0) { return false; } - // Очищаем C_ перед вычислениями - std::fill(C_.begin(), C_.end(), 0.0); + // Очищаем C_ перед вычислениями - заменяем std::fill на цикл + for (size_t i = 0; i < C_.size(); ++i) { + C_[i] = 0.0; + } const int n_int = static_cast(n_); const int block_size = CalculateBlockSize(n_int); @@ -71,17 +22,14 @@ bool MatmulDoubleSeqTask::RunImpl() { const int k_start = kb * block_size; const int k_end = std::min(k_start + block_size, n_int); - ProcessBlock(A_, B_, C_, n_int, i_start, i_end, j_start, j_end, k_start, k_end); + ProcessBlock(A_, B_, C_, n_int, + i_start, i_end, + j_start, j_end, + k_start, k_end); } } } GetOutput() = C_; return true; -} - -bool MatmulDoubleSeqTask::PostProcessingImpl() { - return true; -} - -} // namespace makoveeva_matmul_double_seq +} \ No newline at end of file diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index b2fa0bed..9268d6f8 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -1,20 +1,14 @@ -#include - -#include -#include -#include -#include -#include - -#include "makoveeva_matmul_double_seq/common/include/common.hpp" -#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" -#include "util/include/perf_test_util.hpp" - -namespace makoveeva_matmul_double_seq { namespace { -void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { - std::fill(c.begin(), c.end(), 0.0); +void ReferenceMultiply(const std::vector& a, + const std::vector& b, + std::vector& c, + size_t n) { + // Заменяем std::fill на цикл + for (size_t i = 0; i < c.size(); ++i) { + c[i] = 0.0; + } + for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { const double tmp = a[(i * n) + k]; @@ -25,68 +19,4 @@ void ReferenceMultiply(const std::vector &a, const std::vector & } } -} // namespace - -class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests { - InType input_data_; - std::vector expected_output_; - - protected: - void SetUp() override { - const size_t n = 400; - const size_t size = n * n; - - std::vector a(size); - std::vector b(size); - - for (size_t i = 0; i < size; ++i) { - a[i] = static_cast(i + 1); - b[i] = static_cast(size - i); - } - - input_data_ = std::make_tuple(n, a, b); - - expected_output_.resize(size); - ReferenceMultiply(a, b, expected_output_, n); - } - - bool CheckTestOutputData(OutType &output_data) final { - const auto &expected = expected_output_; - const auto &actual = output_data; - - if (expected.size() != actual.size()) { - return false; - } - - const double epsilon = 1e-7; - for (size_t i = 0; i < expected.size(); ++i) { - if (std::abs(expected[i] - actual[i]) > epsilon) { - return false; - } - } - return true; - } - - InType GetTestInputData() final { - return input_data_; - } -}; - -TEST_P(MatmulDoublePerformanceTest, RunPerfModes) { - ExecuteTest(GetParam()); -} - -namespace { - -const auto kAllPerfTasks = - ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); - -const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); - -const auto kPerfTestName = MatmulDoublePerformanceTest::CustomPerfTestName; - -INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerformanceTest, kGtestValues, kPerfTestName); - -} // namespace - -} // namespace makoveeva_matmul_double_seq +} // namespace \ No newline at end of file From a5c3a8b2e85e3b7aa59093048b62e222f15f2621 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:29:47 +0300 Subject: [PATCH 14/18] tidy!!!1 --- tasks/makoveeva_matmul_double_seq/report.md | 0 tasks/makoveeva_matmul_double_seq/seq/report.md | 0 tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp | 7 ++----- .../tests/performance/main.cpp | 9 +++------ 4 files changed, 5 insertions(+), 11 deletions(-) delete mode 100644 tasks/makoveeva_matmul_double_seq/report.md delete mode 100644 tasks/makoveeva_matmul_double_seq/seq/report.md diff --git a/tasks/makoveeva_matmul_double_seq/report.md b/tasks/makoveeva_matmul_double_seq/report.md deleted file mode 100644 index e69de29b..00000000 diff --git a/tasks/makoveeva_matmul_double_seq/seq/report.md b/tasks/makoveeva_matmul_double_seq/seq/report.md deleted file mode 100644 index e69de29b..00000000 diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 77c94089..032f5201 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -22,14 +22,11 @@ bool MatmulDoubleSeqTask::RunImpl() { const int k_start = kb * block_size; const int k_end = std::min(k_start + block_size, n_int); - ProcessBlock(A_, B_, C_, n_int, - i_start, i_end, - j_start, j_end, - k_start, k_end); + ProcessBlock(A_, B_, C_, n_int, i_start, i_end, j_start, j_end, k_start, k_end); } } } GetOutput() = C_; return true; -} \ No newline at end of file +} diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index 9268d6f8..a598d805 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -1,14 +1,11 @@ namespace { -void ReferenceMultiply(const std::vector& a, - const std::vector& b, - std::vector& c, - size_t n) { +void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { // Заменяем std::fill на цикл for (size_t i = 0; i < c.size(); ++i) { c[i] = 0.0; } - + for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { const double tmp = a[(i * n) + k]; @@ -19,4 +16,4 @@ void ReferenceMultiply(const std::vector& a, } } -} // namespace \ No newline at end of file +} // namespace From 82b0035e2112561136b083b0c71c40e247023014 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:35:56 +0300 Subject: [PATCH 15/18] tidy!!!2 --- .../seq/src/ops_seq.cpp | 57 ++++++++++++++++++- 1 file changed, 56 insertions(+), 1 deletion(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 032f5201..c1449b91 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -1,9 +1,58 @@ +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" // ЭТО САМОЕ ГЛАВНОЕ! + +#include +#include +#include + +namespace makoveeva_matmul_double_seq { +namespace { + +void ProcessBlock(const std::vector &a, const std::vector &b, std::vector &c, int n, + int i_start, int i_end, int j_start, int j_end, int k_start, int k_end) { + for (int i = i_start; i < i_end; ++i) { + for (int j = j_start; j < j_end; ++j) { + double sum = 0.0; + for (int k = k_start; k < k_end; ++k) { + sum += a[(i * n) + k] * b[(k * n) + j]; + } + c[(i * n) + j] += sum; + } + } +} + +int CalculateBlockSize(int n) { + return std::max(1, static_cast(std::sqrt(static_cast(n)))); +} + +int CalculateNumBlocks(int n, int block_size) { + return (n + block_size - 1) / block_size; +} + +} // namespace + +MatmulDoubleSeqTask::MatmulDoubleSeqTask(const InType &in) + : n_(std::get<0>(in)), A_(std::get<1>(in)), B_(std::get<2>(in)), C_(n_ * n_, 0.0) { + SetTypeOfTask(GetStaticTypeOfTask()); + GetOutput() = C_; +} + +bool MatmulDoubleSeqTask::ValidationImpl() { + const bool valid_n = n_ > 0; + const bool valid_a = A_.size() == n_ * n_; + const bool valid_b = B_.size() == n_ * n_; + return valid_n && valid_a && valid_b; +} + +bool MatmulDoubleSeqTask::PreProcessingImpl() { + return true; +} + bool MatmulDoubleSeqTask::RunImpl() { if (n_ <= 0) { return false; } - // Очищаем C_ перед вычислениями - заменяем std::fill на цикл + // Очищаем C_ перед вычислениями for (size_t i = 0; i < C_.size(); ++i) { C_[i] = 0.0; } @@ -30,3 +79,9 @@ bool MatmulDoubleSeqTask::RunImpl() { GetOutput() = C_; return true; } + +bool MatmulDoubleSeqTask::PostProcessingImpl() { + return true; +} + +} // namespace makoveeva_matmul_double_seq From b3edb7796be7049d7ea030e7e63d1d989ec8e594 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:42:51 +0300 Subject: [PATCH 16/18] tidy!!!3 --- .../tests/performance/main.cpp | 78 ++++++++++++++++++- 1 file changed, 77 insertions(+), 1 deletion(-) diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index a598d805..b0770cdd 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -1,7 +1,19 @@ +#include + +#include +#include // для size_t +#include +#include + +#include "makoveeva_matmul_double_seq/common/include/common.hpp" +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" +#include "util/include/perf_test_util.hpp" + +namespace makoveeva_matmul_double_seq { namespace { void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { - // Заменяем std::fill на цикл + // Очищаем c перед вычислениями for (size_t i = 0; i < c.size(); ++i) { c[i] = 0.0; } @@ -17,3 +29,67 @@ void ReferenceMultiply(const std::vector &a, const std::vector & } } // namespace + +class MatmulDoublePerformanceTest : public ppc::util::BaseRunPerfTests { + InType input_data_; + std::vector expected_output_; + + protected: + void SetUp() override { + const size_t n = 400; + const size_t size = n * n; + + std::vector a(size); + std::vector b(size); + + for (size_t i = 0; i < size; ++i) { + a[i] = static_cast(i + 1); + b[i] = static_cast(size - i); + } + + input_data_ = std::make_tuple(n, a, b); + + expected_output_.resize(size); + ReferenceMultiply(a, b, expected_output_, n); + } + + bool CheckTestOutputData(OutType &output_data) final { + const auto &expected = expected_output_; + const auto &actual = output_data; + + if (expected.size() != actual.size()) { + return false; + } + + const double epsilon = 1e-7; + for (size_t i = 0; i < expected.size(); ++i) { + if (std::abs(expected[i] - actual[i]) > epsilon) { + return false; + } + } + return true; + } + + InType GetTestInputData() final { + return input_data_; + } +}; + +TEST_P(MatmulDoublePerformanceTest, RunPerfModes) { + ExecuteTest(GetParam()); +} + +namespace { + +const auto kAllPerfTasks = + ppc::util::MakeAllPerfTasks(PPC_SETTINGS_makoveeva_matmul_double_seq); + +const auto kGtestValues = ppc::util::TupleToGTestValues(kAllPerfTasks); + +const auto kPerfTestName = MatmulDoublePerformanceTest::CustomPerfTestName; + +INSTANTIATE_TEST_SUITE_P(RunModeTests, MatmulDoublePerformanceTest, kGtestValues, kPerfTestName); + +} // namespace + +} // namespace makoveeva_matmul_double_seq From 5e024615ee104c74f6582ad9108c29f5d7a45d9e Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 22:53:21 +0300 Subject: [PATCH 17/18] tidy!!!4 --- tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp | 11 ++++++----- .../tests/performance/main.cpp | 8 +++----- 2 files changed, 9 insertions(+), 10 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index c1449b91..971262c2 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -1,9 +1,12 @@ -#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" // ЭТО САМОЕ ГЛАВНОЕ! +#include "makoveeva_matmul_double_seq/seq/include/ops_seq.hpp" #include #include +#include // для size_t #include +#include "makoveeva_matmul_double_seq/common/include/common.hpp" // для InType + namespace makoveeva_matmul_double_seq { namespace { @@ -52,10 +55,8 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } - // Очищаем C_ перед вычислениями - for (size_t i = 0; i < C_.size(); ++i) { - C_[i] = 0.0; - } + // Очищаем C_ перед вычислениями - используем assign вместо цикла + C_.assign(C_.size(), 0.0); const int n_int = static_cast(n_); const int block_size = CalculateBlockSize(n_int); diff --git a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp index b0770cdd..b37363ed 100644 --- a/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp +++ b/tasks/makoveeva_matmul_double_seq/tests/performance/main.cpp @@ -1,6 +1,6 @@ #include -#include +#include // для std::abs #include // для size_t #include #include @@ -13,10 +13,8 @@ namespace makoveeva_matmul_double_seq { namespace { void ReferenceMultiply(const std::vector &a, const std::vector &b, std::vector &c, size_t n) { - // Очищаем c перед вычислениями - for (size_t i = 0; i < c.size(); ++i) { - c[i] = 0.0; - } + // Очищаем c перед вычислениями - используем assign вместо цикла + c.assign(c.size(), 0.0); for (size_t i = 0; i < n; ++i) { for (size_t k = 0; k < n; ++k) { From 39f317ff353e6a1de11eef0091edf4c995131bf2 Mon Sep 17 00:00:00 2001 From: sofaprog Date: Thu, 26 Feb 2026 23:19:37 +0300 Subject: [PATCH 18/18] tidy!!!5 --- tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp index 971262c2..738a9dc3 100644 --- a/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp +++ b/tasks/makoveeva_matmul_double_seq/seq/src/ops_seq.cpp @@ -2,7 +2,6 @@ #include #include -#include // для size_t #include #include "makoveeva_matmul_double_seq/common/include/common.hpp" // для InType @@ -55,7 +54,7 @@ bool MatmulDoubleSeqTask::RunImpl() { return false; } - // Очищаем C_ перед вычислениями - используем assign вместо цикла + // Очищаем C_ перед вычислениями C_.assign(C_.size(), 0.0); const int n_int = static_cast(n_);