为什么'的std :: copy` 5倍（！）比我的测试程序`memcpy`慢？(Why i

2019-08-02 02:37发布

站内文章 / 移动开发

34 0

疯言疯语

女 | 书童

私信

这是一个后续行动这个问题，我发布这个程序：

#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <vector>
#include <chrono>

class Stopwatch
{
public:
    typedef std::chrono::high_resolution_clock Clock;

    //! Constructor starts the stopwatch
    Stopwatch() : mStart(Clock::now())
    {
    }

    //! Returns elapsed number of seconds in decimal form.
    double elapsed()
    {
        return 1.0 * (Clock::now() - mStart).count() / Clock::period::den;
    }

    Clock::time_point mStart;
};

struct test_cast
{
    int operator()(const char * data) const
    {
        return *((int*)data);
    }
};

struct test_memcpy
{
    int operator()(const char * data) const
    {
        int result;
        memcpy(&result, data, sizeof(result));
        return result;
    }
};

struct test_memmove
{
    int operator()(const char * data) const
    {
        int result;
        memmove(&result, data, sizeof(result));
        return result;
    }
};

struct test_std_copy
{
    int operator()(const char * data) const
    {
        int result;
        std::copy(data, data + sizeof(int), reinterpret_cast<char *>(&result));
        return result;
    }
};

enum
{
    iterations = 2000,
    container_size = 2000
};

//! Returns a list of integers in binary form.
std::vector<char> get_binary_data()
{
    std::vector<char> bytes(sizeof(int) * container_size);
    for (std::vector<int>::size_type i = 0; i != bytes.size(); i += sizeof(int))
    {
        memcpy(&bytes[i], &i, sizeof(i));
    }
    return bytes;
}

template<typename Function>
unsigned benchmark(const Function & function, unsigned & counter)
{
    std::vector<char> binary_data = get_binary_data();
    Stopwatch sw;
    for (unsigned iter = 0; iter != iterations; ++iter)
    {
        for (unsigned i = 0; i != binary_data.size(); i += 4)
        {
            const char * c = reinterpret_cast<const char*>(&binary_data[i]);
            counter += function(c);
        }
    }
    return unsigned(0.5 + 1000.0 * sw.elapsed());
}

int main()
{
    srand(time(0));
    unsigned counter = 0;

    std::cout << "cast:      " << benchmark(test_cast(),     counter) << " ms" << std::endl;
    std::cout << "memcpy:    " << benchmark(test_memcpy(),   counter) << " ms" << std::endl;
    std::cout << "memmove:   " << benchmark(test_memmove(),  counter) << " ms" << std::endl;
    std::cout << "std::copy: " << benchmark(test_std_copy(), counter) << " ms" << std::endl;
    std::cout << "(counter:  " << counter << ")" << std::endl << std::endl;

}

我注意到，出于某种原因std::copy性能比memcpy的糟糕得多。输出看起来像这样我的Mac上使用gcc 4.7。

g++ -o test -std=c++0x -O0 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      41 ms
memcpy:    46 ms
memmove:   53 ms
std::copy: 211 ms
(counter:  3838457856)

g++ -o test -std=c++0x -O1 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      8 ms
memcpy:    7 ms
memmove:   8 ms
std::copy: 19 ms
(counter:  3838457856)

g++ -o test -std=c++0x -O2 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      3 ms
memcpy:    2 ms
memmove:   3 ms
std::copy: 27 ms
(counter:  3838457856)

g++ -o test -std=c++0x -O3 -Wall -Werror -Wextra -pedantic-errors main.cpp
cast:      2 ms
memcpy:    2 ms
memmove:   3 ms
std::copy: 16 ms
(counter:  3838457856)

正如你所看到的，即使有-O3是高达5倍（！），比memcpy的慢。

其结果是在Linux上相似。

有谁知道为什么吗？

Answer 1:

这不是结果我得到：

> g++ -O3 XX.cpp 
> ./a.out
cast:      5 ms
memcpy:    4 ms
std::copy: 3 ms
(counter:  1264720400)

Hardware: 2GHz Intel Core i7
Memory:   8G 1333 MHz DDR3
OS:       Max OS X 10.7.5
Compiler: i686-apple-darwin11-llvm-g++-4.2 (GCC) 4.2.1

在Linux中，我得到不同的结果：

> g++ -std=c++0x -O3 XX.cpp 
> ./a.out 
cast:      3 ms
memcpy:    4 ms
std::copy: 21 ms
(counter:  731359744)


Hardware:  Intel(R) Xeon(R) CPU E5-2670 0 @ 2.60GHz
Memory:    61363780 kB
OS:        Linux ip-10-58-154-83 3.2.0-29-virtual #46-Ubuntu SMP
Compiler:  g++ (Ubuntu/Linaro 4.6.3-1ubuntu5) 4.6.3

Answer 2:

我同意@ RICI的评论关于制定一个更有意义的基准，所以我用你的改写测试两个向量的基准拷贝memcpy() memmove() std::copy()和std::vector赋值运算符：

#include <algorithm>
#include <iostream>
#include <vector>
#include <chrono>
#include <random>
#include <cstring>
#include <cassert>

typedef std::vector<int> vector_type;

void test_memcpy(vector_type & destv, vector_type const & srcv)
{
    vector_type::pointer       const dest = destv.data();
    vector_type::const_pointer const src  = srcv.data();

    std::memcpy(dest, src, srcv.size() * sizeof(vector_type::value_type));
}

void test_memmove(vector_type & destv, vector_type const & srcv)
{
    vector_type::pointer       const dest = destv.data();
    vector_type::const_pointer const src  = srcv.data();

    std::memmove(dest, src, srcv.size() * sizeof(vector_type::value_type));
}

void test_std_copy(vector_type & dest, vector_type const & src)
{
    std::copy(src.begin(), src.end(), dest.begin());
}

void test_assignment(vector_type & dest, vector_type const & src)
{
    dest = src;
}

auto
benchmark(std::function<void(vector_type &, vector_type const &)> copy_func)
    ->decltype(std::chrono::milliseconds().count())
{
    std::random_device rd;
    std::mt19937 generator(rd());
    std::uniform_int_distribution<vector_type::value_type> distribution;

    static vector_type::size_type const num_elems = 2000;

    vector_type dest(num_elems);
    vector_type src(num_elems);

    // Fill the source and destination vectors with random data.
    for (vector_type::size_type i = 0; i < num_elems; ++i) {
        src.push_back(distribution(generator));
        dest.push_back(distribution(generator));
    }

    static int const iterations = 50000;

    std::chrono::time_point<std::chrono::system_clock> start, end;

    start = std::chrono::system_clock::now();

    for (int i = 0; i != iterations; ++i)
        copy_func(dest, src);

    end = std::chrono::system_clock::now();

    assert(src == dest);

    return
        std::chrono::duration_cast<std::chrono::milliseconds>(
            end - start).count();
}

int main()
{
    std::cout
        << "memcpy:     " << benchmark(test_memcpy)     << " ms" << std::endl
        << "memmove:    " << benchmark(test_memmove)    << " ms" << std::endl
        << "std::copy:  " << benchmark(test_std_copy)   << " ms" << std::endl
        << "assignment: " << benchmark(test_assignment) << " ms" << std::endl
        << std::endl;
}

我就有点过分与C ++ 11只是为了好玩。

下面是我得到我的G ++ 4.6.3 64位的Ubuntu框中的结果：

$ g++ -O3 -std=c++0x foo.cpp ; ./a.out 
memcpy:     33 ms
memmove:    33 ms
std::copy:  33 ms
assignment: 34 ms

结果都相当媲美！我得到可比的时间在所有试验情况下，当我改变整数类型，例如，以long long ，在载体为好。

除非我的基准改写坏了，它看起来像你自己的基准不执行有效的比较。 HTH！

Answer 3:

在我看来就像答案是，GCC可以优化这些特定调用的memmove和memcpy，但没有标准::复制。 GCC意识到的memmove和memcpy的语义，并且在这种情况下，可以利用这样的事实，所述尺寸是已知的（的sizeof（int）的）的优势，并将该呼叫到单个mov指令。

的std ::副本中的memcpy方面实现的，但显然GCC优化不设法弄清楚，数据+的sizeof（INT） - 数据是完全的sizeof（int）的。因此，基准调用的memcpy。

我得到了所有通过调用GCC与-S并通过输出快速翻转; 我可以很容易地得到它错了，但我看到了你的测量似乎是一致的。

顺便说一句，我认为测试是或多或少毫无意义。一个更为可能的真实世界的测试可能是创建一个实际的vector<int> src和int[N] dst ，然后比较memcpy(dst, src.data(), sizeof(int)*src.size())与std::copy(src.begin(), src.end(), &dst)

Answer 4:

memcpy和std::copy各有各的用途， std::copy应该（用欢呼声指出，下同）那样的memmove慢，因为没有保证的内存区域会重叠。这意味着您可以复制非连续的区域很容易（因为它支持迭代器）（认为像链表等....实现迭代器甚至是自定义类/结构稀疏分配的结构）。 memcpy只在连续工作的原因，因此，可以高度优化。

Answer 5:

据的汇编输出G ++ 4.8.1 ， test_memcpy ：

movl    (%r15), %r15d

test_std_copy ：

movl    $4, %edx
movq    %r15, %rsi
leaq    16(%rsp), %rdi
call    memcpy

正如你所看到的， std::copy成功地认识到，它可以与复制数据memcpy ，但由于某种原因进一步内联并没有发生-这样的性能差异的原因。

顺便说一句，锵3.4产生用于这两种情况下相同的代码：

movl    (%r14,%rbx), %ebp

文章来源: Why is `std::copy` 5x (!) slower than `memcpy` in my test program?

标签： c++ performance benchmarking

疯言疯语

女 | 书童

私信

收藏的人(0)

Ta的文章更多文章

0条评论

还没有人评论过~