为什么处理排序的数组比处理未排序的数组更快？ ｜ Java Debug 笔记

本文正在参加「Java主题月 - Java Debug笔记活动」，详情查看活动链接

提问：为什么处理排序的数组比处理未排序的数组更快？

下面是一个C++代码，显示了一些非常特殊的行为。出于一些奇怪的原因，奇迹般地对数据进行排序会使代码速度快近六倍：

#include <algorithm>
#include <ctime>
#include <iostream>

int main()
{
    // Generate data
    const unsigned arraySize = 32768;
    int data[arraySize];

    for (unsigned c = 0; c < arraySize; ++c)
        data[c] = std::rand() % 256;

    // !!! With this, the next loop runs faster.
    std::sort(data, data + arraySize);

    // Test
    clock_t start = clock();
    long long sum = 0;
    for (unsigned i = 0; i < 100000; ++i)
    {
        for (unsigned c = 0; c < arraySize; ++c)
        {   // Primary loop
            if (data[c] >= 128)
                sum += data[c];
        }
    }

    double elapsedTime = static_cast<double>(clock() - start) / CLOCKS_PER_SEC;

    std::cout << elapsedTime << std::endl;
    std::cout << "sum = " << sum << std::endl;
}
复制代码

没有，代码在 11.54 秒内运行。std::sort(data, data + arraySize); 使用排序数据，代码在 1.93 秒内运行。 最初，我认为这可能只是一种语言或编译器异常，所以我尝试了Java：

import java.util.Arrays;
import java.util.Random;

public class Main
{
    public static void main(String[] args)
    {
        // Generate data
        int arraySize = 32768;
        int data[] = new int[arraySize];

        Random rnd = new Random(0);
        for (int c = 0; c < arraySize; ++c)
            data[c] = rnd.nextInt() % 256;

        // !!! With this, the next loop runs faster
        Arrays.sort(data);

        // Test
        long start = System.nanoTime();
        long sum = 0;
        for (int i = 0; i < 100000; ++i)
        {
            for (int c = 0; c < arraySize; ++c)
            {   // Primary loop
                if (data[c] >= 128)
                    sum += data[c];
            }
        }

        System.out.println((System.nanoTime() - start) / 1000000000.0);
        System.out.println("sum = " + sum);
    }
}
复制代码

具有类似但不那么极端的结果。

我首先想到的是，排序将数据带入缓存，但后来我想这是多么愚蠢，因为阵列刚刚生成。

1.这是怎么回事？

2.为什么处理排序的数组比处理未排序的数组更快？

高分回答：

考虑铁路交汇点：

现在为了争论，假设这是回到19世纪 - 在长途或无线电通信之前。

你是一个路口的操作员，你听到火车来了。你不知道该走哪条路。你停下来问司机他们想要什么方向。然后适当设置开关。

火车很重，有很强的惯性。因此，他们需要永远启动和减速。

还有更好的方法吗？你猜火车往哪个方向开！

如果你猜对了，它将继续。 如果你猜错了，船长会停下来，站起来，对你大喊大叫，让你翻转开关。然后，它可以重新启动到另一条路径。 如果你每次都猜对了，火车就永远也停不下。 如果你猜错了太多，火车将花费大量的时间停止，备份和重新启动。

考虑如果语句：在处理器级别，它是分支指令：

您是一个处理器，您会看到一个分支。你不知道它会走哪条路。你是做什么工作的？您停止执行并等待之前指令完成。然后，你继续沿着正确的道路。

现代处理器复杂，管道长。因此，他们需要永远"热身"和"慢下来"。

还有更好的方法吗？你猜到树枝会朝哪个方向走！

如果你猜对了，你继续执行。 如果您猜错了，则需要冲洗管道并回滚到分支。然后，您可以沿着其他路径重新启动。 如果你每次都猜对了，执行就永远不能停止。 如果你猜错了太多，你花很多时间拖延，回滚，并重新启动。

这是分支预测。我承认这不是最好的类比， 因为火车可以用旗帜发出方向信号。但在计算机中，处理器直到最后一刻才知道分支将朝哪个方向前进。

那么，您如何从战略上猜测，以尽量减少列车必须备份并沿着另一条道路前进的次数呢？你看看过去的历史！如果火车有99%的时间向左开，那么你猜是左转了。如果它交替，那么你交替你的猜测。如果它每三次走一条路， 你猜的一样...

换句话说，您尝试识别并遵循该模式。 这或多或少是分支预测器的工作原理。

大多数应用程序都有表现良好的分支。因此，现代分支预测器通常会达到>90%的命中率。但是，当面对无法识别的无法识别的分支时，分支预测器几乎毫无用处。

进一步阅读：维基百科上的"分支预测器"文章。

如上所述，罪魁祸首是这种如果声明：

if (data[c] >= 128)
    sum += data[c];
复制代码

请注意，数据均匀分布在 0 和 255 之间。对数据进行排序时，大约迭代的前半部分不会输入如果语句。之后，他们都将进入如果声明。

这对分支预测器非常友好，因为分支连续多次朝同一方向前进。即使是简单的饱和计数器也会正确预测分支，除非它切换方向后会进行少量迭代。

快速可视化：

T = branch taken
N = branch not taken

data[] = 0, 1, 2, 3, 4, ... 126, 127, 128, 129, 130, ... 250, 251, 252, ...
branch = N  N  N  N  N  ...   N    N    T    T    T  ...   T    T    T  ...

       = NNNNNNNNNNNN ... NNNNNNNTTTTTTTTT ... TTTTTTTTTT  (easy to predict)
复制代码

但是，当数据完全随机时，分支预测器变得毫无用处，因为它无法预测随机数据。因此，可能会有大约50%的误判（没有比随机猜测更好）。

data[] = 226, 185, 125, 158, 198, 144, 217, 79, 202, 118,  14, 150, 177, 182, ...
branch =   T,   T,   N,   T,   T,   T,   T,  N,   T,   N,   N,   T,   T,   T  ...

       = TTNTTTTNTNNTTT ...   (completely random - impossible to predict)
复制代码

那么，我们能做些什么呢？

如果编译器无法将分支优化为有条件的移动，则如果您愿意牺牲可读性来提高性能，则可以尝试一些******。

取代：

if (data[c] >= 128)
    sum += data[c];
复制代码

跟：

int t = (data[c] - 128) >> 31;
sum += ~t & data[c];
复制代码

这消除了分支，代之以一些位操作。

（请注意，此***并不严格等同于原始的如果语句。但在这种情况下，它适用于数据的所有输入值[]。

基准： 核心 i7 920 = 3.5 GHz

C++ - 视觉工作室 2010 - x64 发布

场景	时间（秒）
分支 - 随机数据	11.777
分支 - 排序数据	2.352
无分支 - 随机数据	2.564
无分支 - 排序数据	2.587
爪哇 - 网豆 7.1.1 JDK 7 - x64

场景	时间（秒）
分支 - 随机数据	10.93293813
分支 - 排序数据	5.643797077
无分支 - 随机数据	3.113581453
无分支 - 排序数据	3.186068823
复制代码

观察：

与分支：排序数据和未分类数据之间存在巨大差异。 与***：排序数据和未分类数据之间没有区别。 在C++情况下，当数据排序时，***实际上比分支慢一点。 一般的经验法则是避免在关键循环中（例如在本示例中）中依赖数据的分支。

更新：

GCC 4.6.1 带或在 x64 上能够生成有条件移动。因此，排序数据和未分类数据之间没有区别 - 两者都很快。-O3-ftree-vectorize

（或有点快：对于已经排序的情况下，可以慢一点，特别是如果海湾合作委员会把它放在关键路径上，而不仅仅是，特别是在英特尔之前布罗德韦尔有2个周期延迟：gcc优化标志-O3使代码慢于-O2cmovaddcmov)

VC++ 2010 即使在 下也无法为该分支生成有条件的移动。/Ox

英特尔C++编译器（ICC） 11 做了一件奇迹。它交换两个环，从而将不可预知的分支吊到外环。因此，它不仅不受错误预测的影响，而且速度是任何VC++和海合会所能产生的速度的两倍！换句话说，ICC利用测试循环击败了基准。。。

如果你给英特尔编译器无分支代码，它只是右外向量化它。。。和分支（与循环交换）一样快。

这表明，即使是成熟的现代编译器在优化代码的能力上也会大相径庭。。。

标签：...,Java,数据,arraySize,数组,排序,data,分支
来源： https://blog.51cto.com/u_10182395/2787140