Skip to content

Commit bebc5bc

Browse files
aobolenskaobolensk
committed
Make clang-tidy rules more strict
1 parent 5058aa1 commit bebc5bc

File tree

54 files changed

+1685
-1630
lines changed

Some content is hidden

Large Commits have some content hidden by default. Use the searchbox below for content that may be hidden.

54 files changed

+1685
-1630
lines changed

‎.clang-tidy

+17-37
Original file line numberDiff line numberDiff line change
@@ -1,50 +1,30 @@
11
Checks: >
2+
bugprone-*,
3+
clang-diagnostic-*,
4+
llvm-include-order,
5+
llvm-namespace-comment,
6+
misc-*,
27
modernize-*,
38
performance-*,
49
portability-*,
510
readability-*,
11+
-bugprone-casting-through-void,
12+
-bugprone-exception-escape,
13+
-bugprone-implicit-widening-of-multiplication-result,
14+
-bugprone-narrowing-conversions,
15+
-clang-analyzer-optin.cplusplus.UninitializedObject,
16+
-misc-const-correctness,
17+
-misc-no-recursion,
18+
-misc-non-private-member-variables-in-classes,
19+
-misc-unused-parameters,
20+
-misc-use-anonymous-namespace,
621
-modernize-avoid-c-arrays,
7-
-modernize-concat-nested-namespaces,
8-
-modernize-pass-by-value,
9-
-modernize-return-braced-init-list,
1022
-modernize-use-nodiscard,
1123
-modernize-use-trailing-return-type,
24+
-readability-function-cognitive-complexity,
1225
-readability-identifier-length,
1326
-readability-magic-numbers,
14-
-readability-named-parameter,
15-
-readability-redundant-declaration,
16-
bugprone-assignment-in-if-condition,
17-
bugprone-forward-declaration-namespace,
18-
bugprone-infinite-loop,
19-
bugprone-integer-division,
20-
bugprone-macro-parentheses,
21-
bugprone-macro-repeated-side-effects,
22-
bugprone-move-forwarding-reference,
23-
bugprone-redundant-branch-condition,
24-
bugprone-reserved-identifier,
25-
bugprone-suspicious-include,
26-
bugprone-suspicious-semicolon,
27-
bugprone-terminating-continue,
28-
bugprone-throw-keyword-missing,
29-
bugprone-unused-raii,
30-
bugprone-unused-return-value,
31-
clang-diagnostic-*,
32-
llvm-include-order,
33-
llvm-namespace-comment,
34-
misc-confusable-identifiers,
35-
misc-definitions-in-headers,
36-
misc-header-include-cycle,
37-
misc-include-cleaner,
38-
misc-misplaced-const,
39-
misc-non-copyable-objects,
40-
misc-redundant-expression,
41-
misc-static-assert,
42-
misc-throw-by-value-catch-by-reference,
43-
misc-unconventional-assign-operator,
44-
misc-unused-alias-decls,
45-
misc-unused-parameters,
46-
misc-unused-using-decls,
47-
misc-use-anonymous-namespace
27+
-readability-named-parameter
4828
4929
WarningsAsErrors: "*"
5030

‎1stsamples/mpi/main.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,9 @@ int main(int argc, char** argv) {
1616
MPI_Get_processor_name(processor_name, &len_chars);
1717

1818
MPI_Barrier(MPI_COMM_WORLD);
19-
std::cout << "Processor = " << processor_name << std::endl;
20-
std::cout << "Rank = " << world_rank << std::endl;
21-
std::cout << "Number of processors = " << world_size << std::endl;
19+
std::cout << "Processor = " << processor_name << '\n';
20+
std::cout << "Rank = " << world_rank << '\n';
21+
std::cout << "Number of processors = " << world_size << '\n';
2222

2323
MPI_Finalize();
2424
return 0;

‎1stsamples/mpi_boost/main.cpp

+3-5
Original file line numberDiff line numberDiff line change
@@ -1,19 +1,17 @@
1-
#include <mpi.h>
21

32
#include <boost/mpi/communicator.hpp>
43
#include <boost/mpi/environment.hpp>
54
#include <iostream>
6-
#include <string>
75

86
// https://www.boost.org/doc/libs/1_68_0/doc/html/mpi/tutorial.html
97
int main(int argc, char** argv) {
108
boost::mpi::environment env(argc, argv);
119
boost::mpi::communicator world;
1210

1311
world.barrier();
14-
std::cout << "Processor = " << boost::mpi::environment::processor_name() << std::endl;
15-
std::cout << "Rank = " << world.rank() << std::endl;
16-
std::cout << "Number of processors = " << world.size() << std::endl;
12+
std::cout << "Processor = " << boost::mpi::environment::processor_name() << '\n';
13+
std::cout << "Rank = " << world.rank() << '\n';
14+
std::cout << "Number of processors = " << world.size() << '\n';
1715

1816
return 0;
1917
}

‎1stsamples/omp/main.cpp

+2-2
Original file line numberDiff line numberDiff line change
@@ -5,8 +5,8 @@
55
int main() {
66
#pragma omp parallel
77
{
8-
std::cout << "Thread number = " << omp_get_thread_num() << std::endl;
9-
std::cout << "Number of threads = " << omp_get_num_threads() << std::endl;
8+
std::cout << "Thread number = " << omp_get_thread_num() << '\n';
9+
std::cout << "Number of threads = " << omp_get_num_threads() << '\n';
1010
}
1111
return 0;
1212
}

‎1stsamples/stl/main.cpp

+3-3
Original file line numberDiff line numberDiff line change
@@ -3,15 +3,15 @@
33
#include <thread>
44
#include <vector>
55

6-
void task(const std::string& msg) { std::cout << "thread number: " + msg << std::endl; }
6+
static void Task(const std::string& msg) { std::cout << "thread number: " + msg << '\n'; }
77

88
int main() {
99
const auto num_max_threads = std::thread::hardware_concurrency();
10-
std::cout << "Number of threads = " << num_max_threads << std::endl;
10+
std::cout << "Number of threads = " << num_max_threads << '\n';
1111
std::vector<std::thread> thr(num_max_threads);
1212

1313
for (unsigned int i = 0; i < num_max_threads; ++i) {
14-
thr[i] = std::thread(task, std::to_string(i));
14+
thr[i] = std::thread(Task, std::to_string(i));
1515
}
1616

1717
for (unsigned int i = 0; i < num_max_threads; ++i) {

‎1stsamples/tbb/main.cpp

+5-5
Original file line numberDiff line numberDiff line change
@@ -1,18 +1,18 @@
11
#include <tbb/tbb.h>
22

3-
#include <iostream>
3+
#include "oneapi/tbb/task_group.h"
44

5-
int fib_func(int n) {
5+
static int FibFunc(int n) {
66
if (n < 2) {
77
return n;
88
}
99
int x;
1010
int y;
1111
oneapi::tbb::task_group g;
12-
g.run([&] { x = fib_func(n - 1); });
13-
g.run([&] { y = fib_func(n - 2); });
12+
g.run([&] { x = FibFunc(n - 1); });
13+
g.run([&] { y = FibFunc(n - 2); });
1414
g.wait();
1515
return x + y;
1616
}
1717

18-
int main() { return fib_func(10) - 55; }
18+
int main() { return FibFunc(10) - 55; }

‎modules/core/perf/func_tests/perf_tests.cpp

+72-68
Original file line numberDiff line numberDiff line change
@@ -1,39 +1,43 @@
11
#include <gtest/gtest.h>
22

3+
#include <chrono>
4+
#include <cstdint>
5+
#include <memory>
36
#include <vector>
47

58
#include "core/perf/func_tests/test_task.hpp"
69
#include "core/perf/include/perf.hpp"
10+
#include "core/task/include/task.hpp"
711

812
TEST(perf_tests, check_perf_pipeline) {
913
// Create data
1014
std::vector<uint32_t> in(2000, 1);
1115
std::vector<uint32_t> out(1, 0);
1216

1317
// Create TaskData
14-
auto taskData = std::make_shared<ppc::core::TaskData>();
15-
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
16-
taskData->inputs_count.emplace_back(in.size());
17-
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
18-
taskData->outputs_count.emplace_back(out.size());
18+
auto task_data = std::make_shared<ppc::core::TaskData>();
19+
task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
20+
task_data->inputs_count.emplace_back(in.size());
21+
task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
22+
task_data->outputs_count.emplace_back(out.size());
1923

2024
// Create Task
21-
auto testTask = std::make_shared<ppc::test::perf::TestTask<uint32_t>>(taskData);
25+
auto test_task = std::make_shared<ppc::test::perf::TestTask<uint32_t>>(task_data);
2226

2327
// Create Perf attributes
24-
auto perfAttr = std::make_shared<ppc::core::PerfAttr>();
25-
perfAttr->num_running = 10;
28+
auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
29+
perf_attr->num_running = 10;
2630

2731
// Create and init perf results
28-
auto perfResults = std::make_shared<ppc::core::PerfResults>();
32+
auto perf_results = std::make_shared<ppc::core::PerfResults>();
2933

3034
// Create Perf analyzer
31-
ppc::core::Perf perfAnalyzer(testTask);
32-
perfAnalyzer.pipeline_run(perfAttr, perfResults);
35+
ppc::core::Perf perf_analyzer(test_task);
36+
perf_analyzer.pipeline_run(perf_attr, perf_results);
3337

3438
// Get perf statistic
35-
ppc::core::Perf::print_perf_statistic(perfResults);
36-
ASSERT_LE(perfResults->time_sec, ppc::core::PerfResults::MAX_TIME);
39+
ppc::core::Perf::print_perf_statistic(perf_results);
40+
ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::MAX_TIME);
3741
EXPECT_EQ(out[0], in.size());
3842
}
3943

@@ -43,29 +47,29 @@ TEST(perf_tests, check_perf_pipeline_float) {
4347
std::vector<float> out(1, 0);
4448

4549
// Create TaskData
46-
auto taskData = std::make_shared<ppc::core::TaskData>();
47-
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
48-
taskData->inputs_count.emplace_back(in.size());
49-
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
50-
taskData->outputs_count.emplace_back(out.size());
50+
auto task_data = std::make_shared<ppc::core::TaskData>();
51+
task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
52+
task_data->inputs_count.emplace_back(in.size());
53+
task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
54+
task_data->outputs_count.emplace_back(out.size());
5155

5256
// Create Task
53-
auto testTask = std::make_shared<ppc::test::perf::TestTask<float>>(taskData);
57+
auto test_task = std::make_shared<ppc::test::perf::TestTask<float>>(task_data);
5458

5559
// Create Perf attributes
56-
auto perfAttr = std::make_shared<ppc::core::PerfAttr>();
57-
perfAttr->num_running = 10;
60+
auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
61+
perf_attr->num_running = 10;
5862

5963
// Create and init perf results
60-
auto perfResults = std::make_shared<ppc::core::PerfResults>();
64+
auto perf_results = std::make_shared<ppc::core::PerfResults>();
6165

6266
// Create Perf analyzer
63-
ppc::core::Perf perfAnalyzer(testTask);
64-
perfAnalyzer.pipeline_run(perfAttr, perfResults);
67+
ppc::core::Perf perf_analyzer(test_task);
68+
perf_analyzer.pipeline_run(perf_attr, perf_results);
6569

6670
// Get perf statistic
67-
ppc::core::Perf::print_perf_statistic(perfResults);
68-
ASSERT_LE(perfResults->time_sec, ppc::core::PerfResults::MAX_TIME);
71+
ppc::core::Perf::print_perf_statistic(perf_results);
72+
ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::MAX_TIME);
6973
EXPECT_EQ(out[0], in.size());
7074
}
7175

@@ -75,34 +79,34 @@ TEST(perf_tests, check_perf_pipeline_uint8_t_slow_test) {
7579
std::vector<uint8_t> out(1, 0);
7680

7781
// Create TaskData
78-
auto taskData = std::make_shared<ppc::core::TaskData>();
79-
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
80-
taskData->inputs_count.emplace_back(in.size());
81-
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
82-
taskData->outputs_count.emplace_back(out.size());
82+
auto task_data = std::make_shared<ppc::core::TaskData>();
83+
task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
84+
task_data->inputs_count.emplace_back(in.size());
85+
task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
86+
task_data->outputs_count.emplace_back(out.size());
8387

8488
// Create Task
85-
auto testTask = std::make_shared<ppc::test::perf::FakePerfTask<uint8_t>>(taskData);
89+
auto test_task = std::make_shared<ppc::test::perf::FakePerfTask<uint8_t>>(task_data);
8690
// Create Perf attributes
87-
auto perfAttr = std::make_shared<ppc::core::PerfAttr>();
88-
perfAttr->num_running = 1;
91+
auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
92+
perf_attr->num_running = 1;
8993
const auto t0 = std::chrono::high_resolution_clock::now();
90-
perfAttr->current_timer = [&] {
94+
perf_attr->current_timer = [&] {
9195
auto current_time_point = std::chrono::high_resolution_clock::now();
9296
auto duration = std::chrono::duration_cast<std::chrono::nanoseconds>(current_time_point - t0).count();
9397
return static_cast<double>(duration) * 1e-9;
9498
};
9599

96100
// Create and init perf results
97-
auto perfResults = std::make_shared<ppc::core::PerfResults>();
101+
auto perf_results = std::make_shared<ppc::core::PerfResults>();
98102

99103
// Create Perf analyzer
100-
ppc::core::Perf perfAnalyzer(testTask);
101-
perfAnalyzer.pipeline_run(perfAttr, perfResults);
104+
ppc::core::Perf perf_analyzer(test_task);
105+
perf_analyzer.pipeline_run(perf_attr, perf_results);
102106

103107
// Get perf statistic
104-
ASSERT_ANY_THROW(ppc::core::Perf::print_perf_statistic(perfResults));
105-
ASSERT_GE(perfResults->time_sec, ppc::core::PerfResults::MAX_TIME);
108+
ASSERT_ANY_THROW(ppc::core::Perf::print_perf_statistic(perf_results));
109+
ASSERT_GE(perf_results->time_sec, ppc::core::PerfResults::MAX_TIME);
106110
EXPECT_EQ(out[0], in.size());
107111
}
108112

@@ -112,30 +116,30 @@ TEST(perf_tests, check_perf_task) {
112116
std::vector<uint32_t> out(1, 0);
113117

114118
// Create TaskData
115-
auto taskData = std::make_shared<ppc::core::TaskData>();
116-
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
117-
taskData->inputs_count.emplace_back(in.size());
118-
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
119-
taskData->outputs_count.emplace_back(out.size());
119+
auto task_data = std::make_shared<ppc::core::TaskData>();
120+
task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
121+
task_data->inputs_count.emplace_back(in.size());
122+
task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
123+
task_data->outputs_count.emplace_back(out.size());
120124

121125
// Create Task
122-
auto testTask = std::make_shared<ppc::test::perf::TestTask<uint32_t>>(taskData);
126+
auto test_task = std::make_shared<ppc::test::perf::TestTask<uint32_t>>(task_data);
123127

124128
// Create Perf attributes
125-
auto perfAttr = std::make_shared<ppc::core::PerfAttr>();
126-
perfAttr->num_running = 10;
129+
auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
130+
perf_attr->num_running = 10;
127131

128132
// Create and init perf results
129-
auto perfResults = std::make_shared<ppc::core::PerfResults>();
133+
auto perf_results = std::make_shared<ppc::core::PerfResults>();
130134

131135
// Create Perf analyzer
132-
ppc::core::Perf perfAnalyzer(testTask);
133-
perfAnalyzer.task_run(perfAttr, perfResults);
136+
ppc::core::Perf perf_analyzer(test_task);
137+
perf_analyzer.task_run(perf_attr, perf_results);
134138

135139
// Get perf statistic
136-
perfResults->type_of_running = ppc::core::PerfResults::NONE;
137-
ppc::core::Perf::print_perf_statistic(perfResults);
138-
ASSERT_LE(perfResults->time_sec, ppc::core::PerfResults::MAX_TIME);
140+
perf_results->type_of_running = ppc::core::PerfResults::NONE;
141+
ppc::core::Perf::print_perf_statistic(perf_results);
142+
ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::MAX_TIME);
139143
EXPECT_EQ(out[0], in.size());
140144
}
141145

@@ -145,29 +149,29 @@ TEST(perf_tests, check_perf_task_float) {
145149
std::vector<float> out(1, 0);
146150

147151
// Create TaskData
148-
auto taskData = std::make_shared<ppc::core::TaskData>();
149-
taskData->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
150-
taskData->inputs_count.emplace_back(in.size());
151-
taskData->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
152-
taskData->outputs_count.emplace_back(out.size());
152+
auto task_data = std::make_shared<ppc::core::TaskData>();
153+
task_data->inputs.emplace_back(reinterpret_cast<uint8_t *>(in.data()));
154+
task_data->inputs_count.emplace_back(in.size());
155+
task_data->outputs.emplace_back(reinterpret_cast<uint8_t *>(out.data()));
156+
task_data->outputs_count.emplace_back(out.size());
153157

154158
// Create Task
155-
auto testTask = std::make_shared<ppc::test::perf::TestTask<float>>(taskData);
159+
auto test_task = std::make_shared<ppc::test::perf::TestTask<float>>(task_data);
156160

157161
// Create Perf attributes
158-
auto perfAttr = std::make_shared<ppc::core::PerfAttr>();
159-
perfAttr->num_running = 10;
162+
auto perf_attr = std::make_shared<ppc::core::PerfAttr>();
163+
perf_attr->num_running = 10;
160164

161165
// Create and init perf results
162-
auto perfResults = std::make_shared<ppc::core::PerfResults>();
166+
auto perf_results = std::make_shared<ppc::core::PerfResults>();
163167

164168
// Create Perf analyzer
165-
ppc::core::Perf perfAnalyzer(testTask);
166-
perfAnalyzer.task_run(perfAttr, perfResults);
169+
ppc::core::Perf perf_analyzer(test_task);
170+
perf_analyzer.task_run(perf_attr, perf_results);
167171

168172
// Get perf statistic
169-
perfResults->type_of_running = ppc::core::PerfResults::PIPELINE;
170-
ppc::core::Perf::print_perf_statistic(perfResults);
171-
ASSERT_LE(perfResults->time_sec, ppc::core::PerfResults::MAX_TIME);
173+
perf_results->type_of_running = ppc::core::PerfResults::PIPELINE;
174+
ppc::core::Perf::print_perf_statistic(perf_results);
175+
ASSERT_LE(perf_results->time_sec, ppc::core::PerfResults::MAX_TIME);
172176
EXPECT_EQ(out[0], in.size());
173177
}

0 commit comments

Comments
 (0)