Question

我正在寻找一个并行执行比顺序执行更快的例子（在C ++中）。我尝试了一些事情：

对排序数组进行快速排序，

计算1000000个素数，

NxN矩阵求逆

但顺序执行总是更快。如您所见，我使用两个相同的线程来执行threadWrapper(int threadNo)

中的代码

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

using namespace std;

void threadWrapper(int threadNo) {                                              

  clock_t start = clock();                                                    

  cout << "thread " << threadNo << ": started" << endl;                       

  // do something crazy                                                                        

  clock_t ends = clock();                                                     

  cout << "thread " << threadNo << ": has finished, elapsed time " << (double)(ends-start)
}

int main() {                                                                       

  cout << "SEQUENTIALLY:" << endl;                                               

  clock_t seq_start = clock();                                                   

  threadWrapper(1);                                                              
  threadWrapper(2);                                                              

  clock_t seq_ends = clock();                                                    

  cout << "sequentially: elapsed time " << (double)(seq_ends-seq_start)/CLOCKS_PER_SEC <

  cout << endl << "PARALLEL:" << endl;                                           

  clock_t para_start = clock();                                                  

  thread first(threadWrapper, 1);                                                
  thread second(threadWrapper, 2);                                               

  first.join();                                                                  
  second.join();                                                                 

  clock_t para_ends = clock();                                                   

  cout << "parallel: elapsed time " << (double)(para_ends-para_start)/CLOCKS_PER_SEC << 

  return 0;                                                                      
}

你有什么建议吗？

Answer 1

来自std::clock here的Cpp参考：

返回自与程序执行相关的实现定义时代开始以来流程使用的近似处理器时间。

您正在进行的测量是处理时间，而不是挂钟时间。线程不需要 less cpu（它实际上需要更多），但你可以并行执行更多操作，这意味着从用户的角度来看，它运行更快

即。如果每个threadWrapper取1个，则两个计数将指向大约2秒（顺序与并行），但整个过程将在3秒内完成。

Answer 2

在处理线程和并行处理时，请记住以下注意事项：

I / O是瓶颈。
记忆通常是一个瓶颈。
管理线程需要开销。

添加线程可能无法加速应用程序，但它们肯定会使它更复杂。

I / O瓶颈
访问I / O，无论是硬盘驱动器，摄像机数据还是蓝牙发送，都会导致线程等待。如果写得正确，操作系统将挂起线程，直到I / O准备就绪。这也将发生在单线程程序上。

除非你的程序在等待I / O时有办法，否则并行线程在这里不会有帮助。你只需要为RTOS做更多的工作。

内存瓶颈/争用
在大多数具有多个处理器内核的PC和嵌入式应用程序中，通常共享内存（芯片外部）。当一个核心想要在另一个核心访问存储器的同时访问存储器时可能存在争用。一个线程（核心）必须等待另一个线程完成（或交织请求）。这种争论可能会导致您失去效率，而您认为自己会获得这种效率。大多数处理器都使用共享数据总线向内存和内存传输数据。

图形处理单元使程序更有效率，因为它具有自己的内存。当您告诉GPU为对象设置动画时，GPU会使用其内存来消除CPU内存的争用。因此，存在大量的性能提升。

管理线程的开销
线程的创建，维护和销毁会产生开销。使用单个线程或核心应用程序，RTOS可以将其分配给CPU并等待它结束。没多少额外的努力。有了多个内核，现在RTOS必须切换＆＃34;线程＆＃34;在两个核心之间，除了默认核心之外，还监视另一个核心的资源请求和争用。

线程应该执行足够的执行以使线程创建和维护变得有价值。如果附加线程可以从主CPU卸载大量活动，那么它们是值得的。例如，添加两个数字并返回总和的线程太简单而且不值得。将文件读入内存的线程是值得的。

<强>摘要
多个核心和线程不会神奇地执行任务。它们具有创建，操作和销毁开销。经验法则是创建额外的线程，如果它们可以从主CPU异步卸载工作并且经常使用它们。

Answer 3

任何持续爆炸TLB或者必须等待间歇性到突发性主存储器活动的东西。（*编辑：停顿的持续时间越接近生产间隔，生产并行性就会越多。你可能还记得这是缓冲I / O的数学...是的。主存是一个I / O设备这些天。

并行执行比顺序执行快的示例

3 个答案: