1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
|
/*
Copyright (c) 2020-2023 Intel Corporation
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
#include "common/test.h"
#include "common/utils.h"
#include "common/cpu_usertime.h"
#include "common/utils_concurrency_limit.h"
#include "common/parallel_invoke_common.h"
#include "common/memory_usage.h"
#include <cstddef>
#include <atomic>
//! \file test_parallel_invoke.cpp
//! \brief Test for [algorithms.parallel_invoke]
#if !EMSCRIPTEN
//! Emscripten requires preloading of the file used to determine memory usage, hence disabled.
//! Testing parallel_invoke memory usage
//! \brief \ref resource_usage \ref stress
TEST_CASE("Test memory leaks") {
std::size_t number_of_measurements = 500;
std::size_t current_memory_usage = 0, max_memory_usage = 0, stability_counter=0;
// Limit concurrency to prevent extra allocations not dependent on algorithm behavior
auto concurrency_limit = utils::get_platform_max_threads() < 8 ? utils::get_platform_max_threads() : 8;
tbb::global_control control(tbb::global_control::max_allowed_parallelism, concurrency_limit);
for (std::size_t i = 0; i < number_of_measurements; i++) {
{
// ~45000 workload tasks
invoke_tree</*LevelTaskCount*/6, /*Depth*/6, /*WorkSize*/10>::generate_and_run();
}
current_memory_usage = utils::GetMemoryUsage();
if (current_memory_usage > max_memory_usage) {
stability_counter = 0;
max_memory_usage = current_memory_usage;
} else {
stability_counter++;
}
// If the amount of used memory has not changed during 10% of executions,
// then we can assume that the check was successful
if (stability_counter > number_of_measurements / 10) return;
}
REQUIRE_MESSAGE(false, "Seems like we get memory leak here.");
}
#endif
template<typename Body>
void test_from_2_to_10_arguments(const Body& body, const std::atomic<std::size_t>& counter) {
tbb::parallel_invoke(body, body);
tbb::parallel_invoke(body, body, body);
tbb::parallel_invoke(body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body, body, body, body, body);
tbb::parallel_invoke(body, body, body, body, body, body, body, body, body, body);
REQUIRE_MESSAGE(counter == (2 + 10) * 9 / 2,
"Parallel invoke correctness was broken during lambda support test execution.");
}
//! Testing lambdas support
//! \brief \ref error_guessing
TEST_CASE("Test lambda support") {
std::atomic<std::size_t> lambda_counter{0};
auto body = [&]{ lambda_counter++; };
test_from_2_to_10_arguments(body, lambda_counter);
}
std::atomic<std::size_t> func_counter{0};
void func() { func_counter++; };
//! Testing function pointers support
//! \brief \ref error_guessing
TEST_CASE("Test function pointers support") {
auto func_ptr = &func;
test_from_2_to_10_arguments(func_ptr, func_counter);
}
//! Testing workers going to sleep
//! \brief \ref error_guessing
TEST_CASE("Test that all workers sleep when no work") {
invoke_tree</*LevelTaskCount*/9, /*Depth*/6, /*WorkSize*/10>::generate_and_run();
TestCPUUserTime(utils::get_platform_max_threads());
}
|
