Question

仅创建一个线程并加入它会使主线程的执行速度降低50％。正如您在下面的示例中所看到的，线程不执行任何操作，但仍然会对性能产生重大影响。我认为它可能是一个功率/频率缩放相关的问题，所以我试图在创建线程后无法休眠。如果用

编译，下面的程序

g++ -std=c++11 -o out thread_test.cpp -pthread

显示

的结果

Before thread() trial 0 time: 312024526 ignore -1593025974
Before thread() trial 1 time: 243018707 ignore -494037597
Before thread() trial 2 time: 242929293 ignore 177714863
Before thread() trial 3 time: 242935290 ignore 129069571
Before thread() trial 4 time: 243113945 ignore 840242475
Before thread() trial 5 time: 242824224 ignore -1635749271
Before thread() trial 6 time: 242809490 ignore -1256215542
Before thread() trial 7 time: 242910180 ignore -555222712
Before thread() trial 8 time: 235645414 ignore 537501443
Before thread() trial 9 time: 235746347 ignore 118363977
After thread() trial 0 time: 567509646 ignore 223146324
After thread() trial 1 time: 476450035 ignore -393907838
After thread() trial 2 time: 476377789 ignore -1678874628
After thread() trial 3 time: 476377012 ignore -1015350122
After thread() trial 4 time: 476185152 ignore 2034280344
After thread() trial 5 time: 476420949 ignore -1647334529
After thread() trial 6 time: 476354679 ignore 441573900
After thread() trial 7 time: 476120322 ignore -1576726357
After thread() trial 8 time: 476464850 ignore -895798632
After thread() trial 9 time: 475996533 ignore -997590921

而所有试验都应该是相同的速度。

编辑：使用rdtsc（）进行时间测量，使用更长的持续时间，使用计算结果

thread_test.cpp：

#include <ctime>
#include <thread>
#include <iostream>

int dorands(){
  int a =0;
  for(int i=0; i<10000000; i++){
   a +=rand();
  }
  return a;
}

inline uint64_t rdtsc(){
  uint32_t lo, hi;
  __asm__ __volatile__ (
    "xorl %%eax, %%eax\n"
    "cpuid\n"
    "rdtscp\n"
    : "=a" (lo), "=d" (hi)
    :
    : "%ebx", "%ecx" );
  return (uint64_t)hi << 32 | lo;
}


int foo(){return 0;}

int main(){

  uint64_t begin;
  uint64_t end;

  for(int i = 0; i< 10; i++){
    begin= rdtsc();
    volatile int e = dorands();
    end = rdtsc();
    std::cout << "Before thread() trial "<<i<<" time: " << end-begin << " ignore " << e << std::endl;;
  }

  std::thread t1(foo);
  t1.join();

  for(int i = 0; i< 10; i++){
    begin= rdtsc();
    volatile int e = dorands();
    end = rdtsc();
    std::cout << "After thread() trial "<<i<<" time: " << end-begin << " ignore " << e << std::endl;;
  }

  return 1;
}

Answer 1

std::rand()是C rand()，在glibc下invokes __random()。 __random() invokes __libc_lock_lock() and __libc_lock_unlock()，我并不认为如果我们深入研究这些代码，我们会发现锁定基本上不是 - op直到创建一个线程。

Answer 2

我认为你遇到了一个基本的问题：至少在一个典型的多任务操作系统上，有一个范围从大约（比如）几毫秒到一秒左右，在这个范围内很难得到有意义的定时测量。

对于极短的序列，您可以使用时钟计数器（例如，x86上的RDTSC），并运行几次。如果在运行期间发生了任务切换，那么它将严重违反，因为运行时间比其他时间长很多。

这指出了真正的问题：一旦你到达一个序列（例如你的），这个序列需要足够长的时间，几乎可以确定在运行时至少有一个任务开关将发生，然后你遇到了一个问题：任务切换失去的时间可以大大减少时间。特别是，如果任务切换在一次运行期间发生，而不是在另一次运行期间发生，则可以使第二次出现明显快于第一次。

最终，你得到的任务花费的时间足够长，所有这些任务都包含多个任务开关，因此由于任务开关的数量而导致的差异在噪声中几乎丢失了。

注意：理论上，clock应该只测量CPU时间，而不是时钟时间。实际上，完全分解所有任务切换时间几乎是不可能的。

您的测试演示（或者可能演示）另一个相当基本的问题：您的dorand()计算某些内容，但不会（例如）打印出结果。一个足够智能的编译器可以（轻松地）推断出它基本上没有效果，并且基本上完全将它排除在外。

即使您打印出dorand的结果，也没有播种随机数生成器，因此需要在每次运行时生成相同的结果。同样，一个足够智能的编译器可以解决这个问题，并在编译时计算出正确的结果，并打印出三个正确的结果。为了防止我们可以（作为一种可能性）在每次运行时对随机数进行不同的播种 - 通常的方法是检索当前时间，并将其传递给srand。

为了消除（或至少减少）这些问题，我们可以重写代码：

#include <ctime>
#include <thread>
#include <iostream>

long long int dorands(){
  long long int a =0;
  for(int i=0; i<100000000; i++){
    a +=rand();
  }
  return a;
}

int foo(){return 0;}

int main(){
    srand(time(NULL));
  clock_t begin = clock();
  long long int e = dorands();
  clock_t end = clock();
  std::cout << "ignore: " << e << ", trial 1 time: " << end-begin << std::endl;;

  begin = clock();
  e = dorands();
  end = clock();
  std::cout << "ignore: " << e << ", trial 2 time: " << end - begin << std::endl;;

  std::thread t1(foo);
  t1.join();

  begin = clock();
  e = dorands();
  end = clock();
  std::cout << "ignore: " << e << ", trial 3 time: " << end - begin << std::endl;;

  begin = clock();
  e = dorands();
  end = clock();
  std::cout << "ignore: " << e << ", trial 4 time: " << end - begin << std::endl;;


  return 1;
}

这里我打印出dorand返回的值，因此编译器不能完全跳过对rand的调用。我还增加了dorand内的数字，因此每次试用至少运行一秒钟（在我的电脑上，无论如何都会这样做）。

运行它，我得到这样的结果：

ignore: 1638407535924, trial 1 time: 1519
ignore: 1638386748597, trial 2 time: 1455
ignore: 1638433228933, trial 3 time: 1433
ignore: 1638288863328, trial 4 time: 1491

在这个特定的运行中，第一次试验比第二次试验慢（平均），但是有足够的变化和重叠，我们可能非常安全地猜测它只是噪音 - 如果平均速度有任何实际差异，这对我们来说太小了。

创建std :: thread会使主程序减慢50％

2 个答案: