Code Inside:为什么处理已排序数组比处理未排序数组更快?

开发 后端 开发工具
现代处理器都支持指令并行处理和超流水线作业。因此,当处理器遇到程序分支时,都会去猜测应该走哪一条分支。如果猜对了,程序接着流畅运行。如果猜错了,则处理器需要做一些额外的工作,再次回到那条正确的分支。

很久以前在stackoverflow上看到下面这段代码,今天忍不住把它摘录过来。

  1. #include <algorithm>  
  2. #include <ctime>  
  3. #include <iostream>  
  4.    
  5. int main()  
  6. {  
  7.     // Generate data  
  8.     const unsigned arraySize = 32768;  
  9.     int data[arraySize];  
  10.    
  11.     for (unsigned c = 0; c < arraySize; ++c)  
  12.         data[c] = std::rand() % 256;  
  13.    
  14.     // !!! With this, the next loop runs faster  
  15.     std::sort(data, data + arraySize);  
  16.    
  17.     // Test  
  18.     clock_t start = clock();  
  19.     long long sum = 0;  
  20.    
  21.     for (unsigned i = 0; i < 100000; ++i)  
  22.     {  
  23.         // Primary loop  
  24.         for (unsigned c = 0; c < arraySize; ++c)  
  25.         {  
  26.             if (data[c] >= 128)  
  27.                 sum += data[c];  
  28.         }  
  29.     }  
  30.    
  31.     double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;  
  32.    
  33.     std::cout << elapsedTime << std::endl;  
  34.     std::cout << "sum = " << sum << std::endl;  

上面的程序在保留std::sort(data, data + arraySize);语句时,程序运行时间是1.93 

但去掉排序语句后,程序运行时间是11.54

问题:为什么会出现这种情况?

解答分支预测

[[119029]]

程序分支

考虑以下if语句块。对于处理器来说,就是一个分支指令,如下:

处理器每次遇到一条分支时,它都不知道该走哪一条道。这时候该怎么办?程序停下来,等待前面的指令执行完,得到确切的结果后,再接着走某一条分支。

现代处理器都支持指令并行处理和超流水线作业。因此,当处理器遇到程序分支时,都会去猜测应该走哪一条分支。

如果猜对了,程序接着流畅运行。如果猜错了,则处理器需要做一些额外的工作,再次回到那条正确的分支。

因此,如果处理器每次都猜错,那程序的运行时间就会边长。

这就是上面的代码为什么运行时间会相差那么大的原因。

对于分支语句:

  1. if (data[c] >= 128)  
  2.     sum += data[c]; 

在保留std::sort(data, data + arraySize);的情况下。数组data中的内容是这样的:

  1. T = branch taken  
  2. N = branch not taken  
  3.    
  4. data[] = 01234, ... 126127128129130, ... 250251252, ...  
  5. branch = N  N  N  N  N  ...   N    N    T    T    T  ...   T    T    T  ...  
  6.    
  7.        = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT  (easy to predict) 

在未排序的情况下,数组data中的内容是这样的:

  1. data[] = 22618512515819814421779202118,  14150177182133, ...  
  2. branch =   T,   T,   N,   T,   T,   T,   T,  N,   T,   N,   N,   T,   T,   T,   N  ...  
  3.    
  4.        = TTNTTTTNTNNTTTN ...   (completely random - hard to predict) 

也就是说,在已经排序的情况下,处理器便能更好的预测分支了。因此,程序也运行的更快。

关于分支预测

阅读linux源代码时,你会发现if(likely( )){}或是if(unlikely( ))这样的语句。对于条件选择语句,gcc内建了一条指令用于优化,在一个条件经常出现,或者该条件很少出现的时候,编译器可以根据这条指令对条件分支选择进行优化。而Linux内核把这条指令封装成了宏likely()和unlikely()。

因此,在编写程序时,如果一个分支条件只有在很少数的情况下才出现时,我们使用unlikely( )和likely( )能够加快程序的运行,这也是一种优化程序的手段。

比如这样:

  1. if ( unlikely(statement) ) { //这里便是告诉编译器,这个条件只在少数情况下发生  
  2.  
  3. dosomething();  
  4.  

原文链接:http://www.cricode.com/3347.html

责任编辑:林师授 来源: 快课网
相关推荐

2020-10-15 12:30:37

Python编程语言

2021-10-18 11:29:48

奇偶排序数组数据结构算法

2021-11-08 23:09:07

Go排序数据

2021-01-13 10:51:08

PromissetTimeout(函数

2009-11-16 16:17:45

PHP数组排序

2009-11-16 17:35:38

PHP数组排序

2021-11-02 14:54:41

排序数组元素

2021-12-13 11:31:36

排序数组数据结构算法

2009-08-13 10:35:05

Scala数组排序

2009-11-30 18:59:52

PHP数组排序

2017-04-06 14:10:08

JavaScript数组排序

2021-11-17 08:43:17

LeetCode有序数组算法

2021-07-05 06:39:59

经典算法无序数组

2023-09-14 15:48:53

排序测试

2021-09-07 11:01:41

二叉搜索树序数组

2009-11-25 09:56:06

PHP数组处理函数

2009-11-18 11:30:26

PHP数组排序

2009-11-20 09:24:10

PHP多维数组排序

2009-11-24 10:31:22

PHP函数sort()

2020-12-07 15:16:04

排序算法
点赞
收藏

51CTO技术栈公众号