qsort 与 std::sort 的性能？

Question

根据 Scott Meyers 在其 Effective STL 书 - 第 46 项中的说法。他声称 std::sort 比 std::qsort 快约 670%，因为它是内联的。我测试了自己，发现 qsort 更快 :( ！谁能帮我解释一下这种奇怪的行为？

#include <iostream>
#include <vector>
#include <algorithm>

#include <cstdlib>
#include <ctime>
#include <cstdio>

const size_t LARGE_SIZE = 100000;

struct rnd {
    int operator()() {
        return rand() % LARGE_SIZE;
    }
};

int comp( const void* a, const void* b ) {
    return ( *( int* )a - *( int* )b );
}

int main() {
    int ary[LARGE_SIZE];
    int ary_copy[LARGE_SIZE];
    // generate random data
    std::generate( ary, ary + LARGE_SIZE, rnd() );
    std::copy( ary, ary + LARGE_SIZE, ary_copy );
    // get time
    std::time_t start = std::clock();
    // perform quick sort C using function pointer
    std::qsort( ary, LARGE_SIZE, sizeof( int ), comp );
    std::cout << "C quick-sort time elapsed: " << static_cast<double>( clock() - start ) / CLOCKS_PER_SEC << "\n";
    // get time again
    start = std::clock();
    // perform quick sort C++ using function object
    std::sort( ary_copy, ary_copy + LARGE_SIZE );
    std::cout << "C++ quick-sort time elapsed: " << static_cast<double>( clock() - start ) / CLOCKS_PER_SEC << "\n";
}

这是我的结果：

C quick-sort time elapsed: 0.061
C++ quick-sort time elapsed: 0.086
Press any key to continue . . .

更新

有效的 STL 第 3 版 ( 2001 )
第 7 章 STL 编程
第 46 条：考虑函数对象而不是函数作为算法参数。

Answer 1

std::clock() 不是一个可行的计时时钟。您应该使用特定于平台的更高分辨率计时器，例如 Windows 高性能计时器。不仅如此，调用clock()的方式是首先将文本输出到控制台，包含在时间中。这肯定会使测试无效。此外，请确保您在编译时使用了所有优化。

最后，我复制并粘贴了你的代码，qsort 得到 0.016，std::sort 得到 0.008。

Answer 2

我很惊讶没有人提到缓存。

在您的代码中，您首先触摸 ary 和 *ary_copy*，以便它们在 qsort 时驻留在缓存中。在 qsort 期间，*ary_copy* 可能会被驱逐。在 std::sort 时，必须从内存或更大（读取 较慢）缓存级别中获取元素。这当然取决于您的缓存大小。

尝试反转测试，即从运行 std::sort 开始。

正如一些人指出的那样；使数组更大将使测试更公平。原因是大数组不太可能适合缓存。

Answer 3

这两种排序算法在未启用优化的情况下应该具有相当的性能。 C++ sort 明显优于 qsort 的原因是编译器可以内联正在进行的比较，因为编译器具有关于用于执行比较的函数的类型信息。您是否在启用优化的情况下运行这些测试？如果没有，请尝试将其打开并再次运行此测试。

Answer 4

qsort 的性能可能比预期好得多的另一个原因是较新的编译器可以通过函数指针进行内联和优化。

如果 C 头文件定义了 qsort 的内联实现而不是在库中实现它，并且编译器支持间接函数内联，那么 qsort 可以与 std::sort 一样快。

Answer 5

在我的机器上添加一些肉（使数组包含 1000 万个元素并将其移动到数据部分）并编译

g++ -Wall -O2 -osortspeed sortspeed.cpp

我得到了结果

C quick-sort time elapsed: 3.48
C++ quick-sort time elapsed: 1.26

还要注意现代“绿色”CPU，它们可能被配置为根据系统负载以可变速度运行。在进行基准测试时，这种行为会让你发疯（在我的机器上，我有一个小脚本可以修复我在进行速度测试时使用的 CPU 时钟）。

Answer 6

编写准确的基准很困难，所以让Nonius 为我们做吧！让我们在包含一百万个随机整数的向量上测试 qsort、std::sort（没有内联）和 std::sort 内联（默认）。

// sort.cpp
#define NONIUS_RUNNER
#include <nonius.h++>
#include <random>
#include <algorithm>

// qsort
int comp(const void* a, const void* b) {
    const int arg1 = *static_cast<const int*>(a);
    const int arg2 = *static_cast<const int*>(b);

    // we can't simply return a - b, because that might under/overflow
    return (arg1 > arg2) - (arg1 < arg2);
}

// std::sort with no inlining
struct compare_noinline {
    __attribute__((noinline)) bool operator()(const int a, const int b) {
        return a < b;
    }
};

// std::sort with inlining
struct compare {
    // the compiler will automatically inline this
    bool operator()(const int a, const int b) {
        return a < b;
    }
};

std::vector<int> gen_random_vector(const size_t size) {

    std::random_device seed;
    std::default_random_engine engine{seed()};
    std::uniform_int_distribution<int> dist{std::numeric_limits<int>::min(), std::numeric_limits<int>::max()};

    std::vector<int> vec;
    for (size_t i = 0; i < size; i += 1) {
        const int rand_int = dist(engine);
        vec.push_back(rand_int);
    }

    return vec;
}

// generate a vector of a million random integers
constexpr size_t size = 1'000'000;
static const std::vector<int> rand_vec = gen_random_vector(size);

NONIUS_BENCHMARK("qsort", [](nonius::chronometer meter) {

    // Nonius does multiple runs of the benchmark, and each one needs a new
    // copy of the original vector, otherwise we'd just be sorting the same
    // one over and over
    const size_t runs = static_cast<size_t>(meter.runs());
    std::vector<std::vector<int>> vectors{runs};
    std::fill(vectors.begin(), vectors.end(), rand_vec);

    meter.measure([&](const size_t run) {

        std::vector<int>& current_vec = vectors[run];

        std::qsort(current_vec.data(), current_vec.size(), sizeof(int), comp);

        return current_vec;
    });
});

NONIUS_BENCHMARK("std::sort noinline", [](nonius::chronometer meter) {

    const size_t runs = static_cast<size_t>(meter.runs());
    std::vector<std::vector<int>> vectors{runs};
    std::fill(vectors.begin(), vectors.end(), rand_vec);

    meter.measure([&](const size_t run) {

        std::vector<int>& current_vec = vectors[run];

        std::sort(current_vec.begin(), current_vec.end(), compare_noinline{});

        return current_vec;

    });
});

NONIUS_BENCHMARK("std::sort inline", [](nonius::chronometer meter) {

    const size_t runs = static_cast<size_t>(meter.runs());
    std::vector<std::vector<int>> vectors{runs};
    std::fill(vectors.begin(), vectors.end(), rand_vec);

    meter.measure([&](const size_t run) {

        std::vector<int>& current_vec = vectors[run];

        std::sort(current_vec.begin(), current_vec.end(), compare{});

        return current_vec;

    });
});

使用 Apple Clang 7.3.0 编译，

$ clang++ -std=c++14 -stdlib=libc++ -O3 -march=native sort.cpp -o sort
$ ./sort

在我的 1.7 GHz i5 Macbook Air 上运行它，我们得到

qsort                211 ms +/- 6 ms
std::sort noinline   127 ms +/- 5 ms
std::sort inline      87 ms +/- 4 ms

因此，没有内联的 std::sort 比 qsort 快大约 1.7 倍（可能是由于不同的排序算法），而内联则快了大约 2.4 倍。当然是令人印象深刻的加速，但远低于 670%。

Answer 7

为什么在 C 标准库的比较函数中没有人提到额外的内存获取？

在C标准库中，void*用于保存所有类型的成员数据，这意味着当实际访问成员数据时，必须对void*指针进行一次额外的解引用。

struct list {
        void *p_data; // deference this pointer when access real data
        struct list *prev;
        struct list *next;
};

但是，在STL中，借助模板的代码生成能力，C标准库中用void*保存的成员数据可以直接放在类型内部，避免了访问过程中额外的解引用。

template <typename T>
class list {
public:
        T data; // access data directly
        list *prev;
        list *next;
};

所以，理论上，std::sort 比 qsort 快。

Answer 8

我不确定快 670%。它一定是为显示std::sort 的速度而量身定制的特定数据集。一般来说，std::sort 确实比 qsort 快，因为以下几点：

1. qsort 对void* 进行操作，首先需要取消引用，其次需要数据类型的大小来执行交换。因此，qsort 的交换操作是每个字节进行的。查看qsort 实现并注意它的SWAP 宏是一个循环。这是 Jon Bentley 解释时间差异的视频（从 45m 开始）：https://www.youtube.com/watch?v=aMnn0Jq0J-E&t=2700s

2. inline 可能会使它加快一点，但那是微优化，不是主要贡献者。

3. std::sort实际上是一种混合算法，称为Introsort。 C qsort 是一个纯粹的快速排序实现。给定一个不适合快速排序的数据集，std::sort 改为堆排序。因此，如果您为 qsort 创建了一个错误的输入，它将会非常缓慢。

4. 上面的分析代码是不够的。应增加输入大小。 100K 是不够的。将其增加到 1M 或 10M，然后重复多次排序，然后取平均值或中位数。如有必要，将它们编译成单独的二进制文件并单独运行。