Is chrono::steady_clock blocking on threads?

Question

I ran into an issue when I wanted to spawn a few threads to do some calculations for a set amount of time. But the total time elapsed is always greater than the sum of each threads allocated time, while I expected it to be more of the maximum. What am I not understanding here?

Some example code:

#include <thread>
#include <chrono>

void do_some_wait(int time);

int main() {
  using std::thread;
  thread t1(&do_some_wait, 1);
  thread t2(&do_some_wait, 1);
  thread t3(&do_some_wait, 1);

  t1.join(); t2.join(); t3.join();
}

void do_some_wait(int time) {
  using std::chrono::steady_clock;
  using std::chrono::seconds;
  auto end = steady_clock::now() + seconds(time);

  while (steady_clock::now() < end) { /* some calculations */ }
}

I'd expect this to take ~1 second to execute. But it takes ~3.

$ clang++ -std=c++11 -stdlib=libc++ -Wall -pedantic thread.cpp -o thread && time ./thread
./thread  2.96s user 0.00s system 295% cpu 1.003 total

Answer 1

The 2.96s user in the output from time is how much CPU time you used. If you run three threads, for one second each, on a processor that has at least three cores [and there isn't much competition from other processes], you are going to use best part of 3 seconds of CPU time. The total time is 1.003s, which is reasonable for a 1s times thread plus a little overhead at start/end.

Answer 2

It takes 1.003 seconds. You did not pay attention to the output, which fulfills your expectations.