Link Copied
Hi，
Thanks a lot for your help and I have try to write a demo to explain my previous problem.
We have used lttng to grep the problem like this. As you can see in the picture, we run on 11 cpu core and the thread number used default for tbb::parallel_for. Then is four AsyncThread at the same time do some work to keep oncpu.
Worker_Run represent tbb threads. Dark colors in the same block represent oncpu, and light colors represent offcpu. You can see two tbb::parallel_for will offcpu about 16ms.
The most troublesome thing for us is this kind of offcpu, although this does not necessarily happen every time. If offcpu is turned off, can the task of the current tbb thread be switched to other tbb threads, instead of all tbb threads waiting for this thread to finish executing? Binding cores of different threads can definitely solve this problem, but if Asyncthread is executed only 10% of the time, this will cause a waste of CPU.
And this is the demo code:
int main() {
TRACE_EVENT_SCOPE(planner, MainThread);
auto start_time = std::chrono::high_resolution_clock::now();
std::vector<std::future<bool>> future_results;
for (int i = 0; i < 4; ++i) {
future_results.push_back(std::async([](){
auto start_time = std::chrono::high_resolution_clock::now();
usleep(3000);
TRACE_EVENT_SCOPE(planner, AsyncThread);
while (true) {
auto current_time = std::chrono::high_resolution_clock::now();
auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time);
if (elapsed_time.count() >= 20) {
break;
}
}
return true;
}));
}
tbb::parallel_for(tbb::blocked_range<int>(0, 49), [](tbb::blocked_range<int> r) {
for (int i = r.begin(); i != r.end(); ++i) {
auto start_time = std::chrono::high_resolution_clock::now();
while (true) {
auto current_time = std::chrono::high_resolution_clock::now();
auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time);
if (elapsed_time.count() >= 1) {
break;
}
}
}
});
}
Meanwhile, if we run a tbb::parallel_for in the main thread, another tbb::parallel_for in the async thread. We can also see the offcpu and the exec time of async thread is 18ms.
Demo code is like this:
int main() {
TRACE_EVENT_SCOPE(planner, MainThread);
auto start_time = std::chrono::high_resolution_clock::now();
std::vector<std::future<bool>> future_results;
for (int i = 0; i < 1; ++i) {
future_results.push_back(std::async([](){
usleep(3000);
TRACE_EVENT_SCOPE(planner, AsyncThread);
tbb::parallel_for(tbb::blocked_range<int>(0, 19), [](tbb::blocked_range<int> r) {
for (int i = r.begin(); i != r.end(); ++i) {
auto start_time = std::chrono::high_resolution_clock::now();
while (true) {
auto current_time = std::chrono::high_resolution_clock::now();
auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time);
if (elapsed_time.count() >= 1) {
break;
}
}
}
});
return true;
}));
}
tbb::parallel_for(tbb::blocked_range<int>(0, 199), [](tbb::blocked_range<int> r) {
for (int i = r.begin(); i != r.end(); ++i) {
auto start_time = std::chrono::high_resolution_clock::now();
while (true) {
auto current_time = std::chrono::high_resolution_clock::now();
auto elapsed_time = std::chrono::duration_cast<std::chrono::milliseconds>(current_time - start_time);
if (elapsed_time.count() >= 1) {
break;
}
}
}
});
std::for_each(future_results.begin(), future_results.end(), [](std::future<bool>& future) {
bool result = future.get();
});
auto end_time = std::chrono::high_resolution_clock::now();
auto run_time = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
LOG(ERROR) << "run time is: " << run_time.count();
}
