GCC Code Coverage Report

Directory: ./
File: tasks/kichanova_k_lin_system_by_conjug_grad/tbb/src/ops_tbb.cpp
Date: 2026-06-04 20:25:32
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 120 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 120 const auto stride = static_cast<size_t>(n);
19
20 240 tbb::parallel_for(tbb::blocked_range<int>(0, n, 64), [&](const tbb::blocked_range<int> &range) {
21
2/2
✓ Branch 0 taken 596 times.
✓ Branch 1 taken 120 times.
 716 for (int i = range.begin(); i < range.end(); ++i) {
22 double sum = 0.0;
23 596 const double *a_row = &a[static_cast<size_t>(i) * stride];
24
2/2
✓ Branch 0 taken 3284 times.
✓ Branch 1 taken 596 times.
 3880 for (int j = 0; j < n; ++j) {
25 3284 sum += a_row[j] * v[j];
26 }
27 596 result[i] = sum;
28 596 x[i] += alpha * p[i];
29 }
30 120 });
31 120 }
32
33 156 double ComputeResidualNorm(const std::vector<double> &r, int n) {
34 312 double rr = tbb::parallel_reduce(tbb::blocked_range<int>(0, n, 1024), 0.0,
35 156 [&](const tbb::blocked_range<int> &range, double local_sum) {
36
2/4
✓ Branch 0 taken 744 times.
✓ Branch 1 taken 156 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 900 for (int i = range.begin(); i < range.end(); ++i) {
37 744 local_sum += r[i] * r[i];
38 }
39 return local_sum;
40 ✗ }, [](double x, double y) { return x + y; });
41 156 return std::sqrt(rr);
42 }
43
44 120 double ComputeDotProduct(const std::vector<double> &a, const std::vector<double> &b, int n) {
45 240 return tbb::parallel_reduce(tbb::blocked_range<int>(0, n, 1024), 0.0,
46 120 [&](const tbb::blocked_range<int> &range, double local_sum) {
47
2/2
✓ Branch 0 taken 596 times.
✓ Branch 1 taken 120 times.
 716 for (int i = range.begin(); i < range.end(); ++i) {
48 596 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 72 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
56
2/4
✓ Branch 0 taken 148 times.
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 184 for (int i = range.begin(); i < range.end(); ++i) {
57 148 r[i] = b[i];
58 148 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 120 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
66
2/2
✓ Branch 0 taken 596 times.
✓ Branch 1 taken 120 times.
 716 for (int i = range.begin(); i < range.end(); ++i) {
67 596 x[i] += alpha * p[i];
68 596 r[i] -= alpha * ap[i];
69 }
70 120 });
71 }
72
73 void UpdateDirection(std::vector<double> &p, const std::vector<double> &r, double beta, int n) {
74 168 tbb::parallel_for(tbb::blocked_range<int>(0, n, 1024), [&](const tbb::blocked_range<int> &range) {
75
2/4
✓ Branch 0 taken 448 times.
✓ Branch 1 taken 84 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
 532 for (int i = range.begin(); i < range.end(); ++i) {
76 448 p[i] = r[i] + (beta * p[i]);
77 }
78 });
79 }
80
81 } // namespace
82
83
1/2
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
 36 KichanovaKLinSystemByConjugGradTBB::KichanovaKLinSystemByConjugGradTBB(const InType &in) {
84 SetTypeOfTask(GetStaticTypeOfTask());
85
1/2
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
 36 GetInput() = in;
86 36 GetOutput() = OutType();
87 36 }
88
89 36 bool KichanovaKLinSystemByConjugGradTBB::ValidationImpl() {
90 const InType &input_data = GetInput();
91
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 if (input_data.n <= 0) {
92 return false;
93 }
94
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 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 36 times.
 36 if (input_data.b.size() != static_cast<size_t>(input_data.n)) {
98 ✗ return false;
99 }
100 return true;
101 }
102
103 36 bool KichanovaKLinSystemByConjugGradTBB::PreProcessingImpl() {
104 36 GetOutput().assign(GetInput().n, 0.0);
105 36 return true;
106 }
107
108
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 bool KichanovaKLinSystemByConjugGradTBB::RunImpl() {
109 const InType &input_data = GetInput();
110 OutType &x = GetOutput();
111
112 36 int n = input_data.n;
113
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 if (n == 0) {
114 return false;
115 }
116
117 36 const std::vector<double> &a = input_data.A;
118 36 const std::vector<double> &b = input_data.b;
119 36 double epsilon = input_data.epsilon;
120
121 36 std::vector<double> r(n);
122
1/4
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 36 std::vector<double> p(n);
123
2/6
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 36 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
 36 std::vector<double> ap(n);
124
125 InitializeVectors(r, p, b, n);
126
127
1/2
✓ Branch 1 taken 36 times.
✗ Branch 2 not taken.
 36 double residual_norm = ComputeResidualNorm(r, n);
128
1/2
✓ Branch 0 taken 36 times.
✗ Branch 1 not taken.
 36 if (residual_norm < epsilon) {
129 return true;
130 }
131
132 36 double rr_old = residual_norm * residual_norm;
133 36 int max_iter = n * 1000;
134
135
1/2
✓ Branch 0 taken 120 times.
✗ Branch 1 not taken.
 120 for (int iter = 0; iter < max_iter; ++iter) {
136
1/2
✓ Branch 1 taken 120 times.
✗ Branch 2 not taken.
 120 ComputeMatrixVectorAndUpdateTBB(a, p, ap, n, 0.0, x, p);
137
138
1/2
✓ Branch 1 taken 120 times.
✗ Branch 2 not taken.
 120 double p_ap = ComputeDotProduct(p, ap, n);
139
1/2
✓ Branch 0 taken 120 times.
✗ Branch 1 not taken.
 120 if (std::abs(p_ap) < 1e-30) {
140 break;
141 }
142
143
1/2
✓ Branch 1 taken 120 times.
✗ Branch 2 not taken.
 120 double alpha = rr_old / p_ap;
144 120 UpdateSolutionAndResidual(x, r, p, ap, alpha, n);
145
146
1/2
✓ Branch 1 taken 120 times.
✗ Branch 2 not taken.
 120 residual_norm = ComputeResidualNorm(r, n);
147
2/2
✓ Branch 0 taken 84 times.
✓ Branch 1 taken 36 times.
 120 if (residual_norm < epsilon) {
148 break;
149 }
150
151 84 double rr_new = residual_norm * residual_norm;
152
1/2
✓ Branch 1 taken 84 times.
✗ Branch 2 not taken.
 84 double beta = rr_new / rr_old;
153 84 UpdateDirection(p, r, beta, n);
154
155 rr_old = rr_new;
156 }
157
158 return true;
159 }
160
161 36 bool KichanovaKLinSystemByConjugGradTBB::PostProcessingImpl() {
162 36 return true;
163 }
164
165 } // namespace kichanova_k_lin_system_by_conjug_grad
166