Задержка пула потоков очень высока на однопроцессорной машине?

Я использую пул потоков для параллельного выполнения задачи.

вот код, который я использую:

pragma once
#include <vector>
#include <queue>
#include <memory>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <future>
#include <functional>
#include <stdexcept>

class ThreadPool {
public:
  ThreadPool(size_t threads) : stop(false) {
    for(size_t i = 0; i < threads; ++i)
      workers.emplace_back(  // thread variable, emplace back just pass in a function for thread to construct
        [this] {
          for(;;) {
            std::function<void()> task;
            {   
              std::unique_lock<std::mutex> lock(this->queue_mutex);
              this->condition.wait(lock, [this] { return this->stop || !this->tasks.empty(); }); 
              if (this->stop && this->tasks.empty()) return;  // only on stop and empty task, perfect exit
              task = std::move(this->tasks.front());  // get the first task
              this->tasks.pop();
            }   
            task();
          }   
        }); 
  }


  template<class F, class... Args>
  auto enqueue(F&& f, Args&&... args) -> std::future<typename std::result_of<F(Args...)>::type> {
    using return_type = typename std::result_of<F(Args...)>::type;
    auto task = std::make_shared< std::packaged_task<return_type()> >(std::bind(std::forward<F>(f), std::forward<Args>(args)...));
    std::future<return_type> res = task->get_future();
    {   
      std::unique_lock<std::mutex> lock(queue_mutex);
      // don't allow enqueueing after stopping the pool
      if (stop) throw std::runtime_error("enqueue on stopped ThreadPool");
      tasks.emplace([task](){ (*task)(); }); 
    }   
    condition.notify_one();
    return res;
  }

  ~ThreadPool() {
    {   
      std::unique_lock<std::mutex> lock(queue_mutex);
      stop = true;
    }   
    condition.notify_all();
    for(std::thread &worker: workers) worker.join();
  }
private:
    std::vector< std::thread > workers;
    std::queue< std::function<void()> > tasks;
    std::mutex queue_mutex;
    std::condition_variable condition;
    bool stop;
};

main.cpp это:

#include "./thread_pool.hpp"
#include <sys/time.h>

int main() {
  ThreadPool tp(16);
  timeval t;
  for (size_t i = 0; i < 16; ++i) {
    gettimeofday(&t, NULL);
    tp.enqueue([t, i]() {
      timeval t1; 
      gettimeofday(&t1, NULL);
      int lat = (t1.tv_sec - t.tv_sec) * 1000000 + t1.tv_usec - t.tv_usec;
      printf("this is loop %zu, lat = %d\n", i, lat);
    }); 
  }
}

я тестирую задержку этого кода (задержку накладных расходов).

результат меня удивил.

на моей машине i9 10900k с 16 процессорами задержка составляет всего около 30 мкс для каждой задачи.

на моей машине aws с двумя процессорами задержка достигнет > 10000 мкс.

Я знаю, что 2-процессорный процессор с 16 потоками - это не настоящая паралла, но я думаю, что он будет замедляться только с 30-50 мкс.

до 10 000 долларов США — это намного больше, чем я ожидал, где же временные затраты?