GCC Code Coverage Report

Directory: ./
File: tasks/kichanova_k_lin_system_by_conjug_grad/tbb/src/ops_tbb.cpp
Date: 2026-05-11 08:26:31
Exec Total Coverage
Lines: 71 74 95.9%
Functions: 10 10 100.0%
Branches: 35 64 54.7%
Line Branch Exec Source
1 #include "kichanova_k_lin_system_by_conjug_grad/tbb/include/ops_tbb.hpp"
2
3 #include <tbb/tbb.h>
4
5 #include <cmath>
6 #include <cstddef>
7 #include <vector>
8
9 #include "kichanova_k_lin_system_by_conjug_grad/common/include/common.hpp"
10
11 namespace kichanova_k_lin_system_by_conjug_grad {
12
13 namespace {
14
15 218 void ComputeMatrixVectorAndUpdateTBB(const std::vector<double> &a, const std::vector<double> &v,
16 std::vector<double> &result, int n, double alpha, std::vector<double> &x,
17 const std::vector<double> &p) {
18 218 const auto stride = static_cast<size_t>(n);
19
20 436 tbb::parallel_for(tbb::blocked_range<int>(0, n, 64), [&](const tbb::blocked_range<int> &range) {
21
2/2
✓ Branch 0 taken 1408 times.
✓ Branch 1 taken 218 times.
 1626 for (int i = range.begin(); i < range.end(); ++i) {
22 double sum = 0.0;
23 1408 const double *a_row = &a[static_cast<size_t>(i) * stride];
24
2/2
✓ Branch 0 taken 10444 times.
✓ Branch 1 taken 1408 times.
 11852 for (int j = 0; j < n; ++j) {
25 10444 sum += a_row[j] * v[j];
26 }
27 1408 result[i] = sum;
28 1408 x[i] += alpha * p[i];
29 }
30 218 });
31 218 }
32
33 266 double ComputeResidualNorm(const std::vector<double> &r, int n) {
34 532 double rr = tbb::parallel_reduce(tbb::blocked_range<int>(0, n, 1024), 0.0,
35 266 [&](const tbb::blocked_range<int> &range, double local_sum) {
36
2/4
✓ Branch 0 taken 1644 times.
✓ Branch 1 taken 266 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1910 for (int i = range.begin(); i < range.end(); ++i) {
37 1644 local_sum += r[i] * r[i];
38 }
39 return local_sum;
40 ✗ }, [](double x, double y) { return x + y; });
41 266 return std::sqrt(rr);
42 }
43
44 218 double ComputeDotProduct(const std::vector<double> &a, const std::vector<double> &b, int n) {
45 436 return tbb::parallel_reduce(tbb::blocked_range<int>(0, n, 1024), 0.0,
46 218 [&](const tbb::blocked_range<int> &range, double local_sum) {
47
2/2
✓ Branch 0 taken 1408 times.
✓ Branch 1 taken 218 times.
 1626 for (int i = range.begin(); i < range.end(); ++i) {
48 1408 local_sum += a[i] * b[i];
49 }
50 return local_sum;
51 ✗ }, [](double x, double y) { return x + y; });
52 }
53
54 void InitializeVectors(std::vector<double> &r, std::vector<double> &p, const std::vector<double> &b, int n) {
55 96 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
56
2/4
✓ Branch 0 taken 236 times.
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 284 for (int i = range.begin(); i < range.end(); ++i) {
57 236 r[i] = b[i];
58 236 p[i] = r[i];
59 }
60 });
61 }
62
63 void UpdateSolutionAndResidual(std::vector<double> &x, std::vector<double> &r, const std::vector<double> &p,
64 const std::vector<double> &ap, double alpha, int n) {
65 218 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
66
2/2
✓ Branch 0 taken 1408 times.
✓ Branch 1 taken 218 times.
 1626 for (int i = range.begin(); i < range.end(); ++i) {
67 1408 x[i] += alpha * p[i];
68 1408 r[i] -= alpha * ap[i];
69 }
70 218 });
71 }
72
73 void UpdateDirection(std::vector<double> &p, const std::vector<double> &r, double beta, int n) {
74 340 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
75
2/4
✓ Branch 0 taken 1172 times.
✓ Branch 1 taken 170 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 1342 for (int i = range.begin(); i < range.end(); ++i) {
76 1172 p[i] = r[i] + (beta * p[i]);
77 }
78 });
79 }
80
81 } // namespace
82
83
1/2
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
 48 KichanovaKLinSystemByConjugGradTBB::KichanovaKLinSystemByConjugGradTBB(const InType &in) {
84 SetTypeOfTask(GetStaticTypeOfTask());
85
1/2
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
 48 GetInput() = in;
86 48 GetOutput() = OutType();
87 48 }
88
89 48 bool KichanovaKLinSystemByConjugGradTBB::ValidationImpl() {
90 const InType &input_data = GetInput();
91
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 if (input_data.n <= 0) {
92 return false;
93 }
94
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 if (input_data.A.size() != static_cast<size_t>(input_data.n) * static_cast<size_t>(input_data.n)) {
95 return false;
96 }
97
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 48 times.
 48 if (input_data.b.size() != static_cast<size_t>(input_data.n)) {
98 ✗ return false;
99 }
100 return true;
101 }
102
103 48 bool KichanovaKLinSystemByConjugGradTBB::PreProcessingImpl() {
104 48 GetOutput().assign(GetInput().n, 0.0);
105 48 return true;
106 }
107
108
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 bool KichanovaKLinSystemByConjugGradTBB::RunImpl() {
109 const InType &input_data = GetInput();
110 OutType &x = GetOutput();
111
112 48 int n = input_data.n;
113
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 if (n == 0) {
114 return false;
115 }
116
117 48 const std::vector<double> &a = input_data.A;
118 48 const std::vector<double> &b = input_data.b;
119 48 double epsilon = input_data.epsilon;
120
121 48 std::vector<double> r(n);
122
1/4
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 48 std::vector<double> p(n);
123
2/6
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 48 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 48 std::vector<double> ap(n);
124
125 InitializeVectors(r, p, b, n);
126
127
1/2
✓ Branch 1 taken 48 times.
✗ Branch 2 not taken.
 48 double residual_norm = ComputeResidualNorm(r, n);
128
1/2
✓ Branch 0 taken 48 times.
✗ Branch 1 not taken.
 48 if (residual_norm < epsilon) {
129 return true;
130 }
131
132 48 double rr_old = residual_norm * residual_norm;
133 48 int max_iter = n * 1000;
134
135
1/2
✓ Branch 0 taken 218 times.
✗ Branch 1 not taken.
 218 for (int iter = 0; iter < max_iter; ++iter) {
136
1/2
✓ Branch 1 taken 218 times.
✗ Branch 2 not taken.
 218 ComputeMatrixVectorAndUpdateTBB(a, p, ap, n, 0.0, x, p);
137
138
1/2
✓ Branch 1 taken 218 times.
✗ Branch 2 not taken.
 218 double p_ap = ComputeDotProduct(p, ap, n);
139
1/2
✓ Branch 0 taken 218 times.
✗ Branch 1 not taken.
 218 if (std::abs(p_ap) < 1e-30) {
140 break;
141 }
142
143
1/2
✓ Branch 1 taken 218 times.
✗ Branch 2 not taken.
 218 double alpha = rr_old / p_ap;
144 218 UpdateSolutionAndResidual(x, r, p, ap, alpha, n);
145
146
1/2
✓ Branch 1 taken 218 times.
✗ Branch 2 not taken.
 218 residual_norm = ComputeResidualNorm(r, n);
147
2/2
✓ Branch 0 taken 170 times.
✓ Branch 1 taken 48 times.
 218 if (residual_norm < epsilon) {
148 break;
149 }
150
151 170 double rr_new = residual_norm * residual_norm;
152
1/2
✓ Branch 1 taken 170 times.
✗ Branch 2 not taken.
 170 double beta = rr_new / rr_old;
153 170 UpdateDirection(p, r, beta, n);
154
155 rr_old = rr_new;
156 }
157
158 return true;
159 }
160
161 48 bool KichanovaKLinSystemByConjugGradTBB::PostProcessingImpl() {
162 48 return true;
163 }
164
165 } // namespace kichanova_k_lin_system_by_conjug_grad
166