这是我发布此计划的this question的后续行动：
#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更糟糕。使用gcc 4.7在我的Mac上输出如下所示。
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，它也比memcpy慢5倍（！）。
Linux上的结果相似。
有谁知道为什么？
答案 0 :(得分：8)
我同意@rici's comment关于开发更有意义的基准测试，因此我重新编写了测试，以使用memcpy()，memmove()，std::copy()和{{对两个向量进行基准复制1}}赋值运算符：
std::vector为了好玩，我对C ++ 11有点过分了。
以下是我在64位Ubuntu框中使用g ++ 4.6.3获得的结果：
#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;
}
结果完全可比！当我在向量中将整数类型例如更改为$ g++ -O3 -std=c++0x foo.cpp ; ./a.out
memcpy: 33 ms
memmove: 33 ms
std::copy: 33 ms
assignment: 34 ms
时，我在所有测试用例中都得到了相似的时间。
除非我的基准重写被破坏，否则您自己的基准测试似乎没有执行有效的比较。 HTH！
答案 1 :(得分：6)
在我看来，答案是gcc可以优化对memmove和memcpy的这些特定调用，而不是std :: copy。 gcc知道memmove和memcpy的语义，在这种情况下可以利用已知大小（sizeof（int））将调用转换为单个mov指令的事实。
std :: copy是用memcpy实现的，但显然gcc优化器无法弄清楚data + sizeof（int） - 数据正好是sizeof（int）。所以基准调用memcpy。
通过使用-S调用gcc并快速翻看输出，我得到了所有这些;我很容易弄错了，但我所看到的似乎与你的测量结果一致。
顺便说一下，我认为测试或多或少没有意义。更合理的实际测试可能是创建实际的vector<int> src和int[N] dst，然后将memcpy(dst, src.data(), sizeof(int)*src.size())与std::copy(src.begin(), src.end(), &dst)进行比较。
答案 2 :(得分：3)
memcpy和std::copy每个都有它们的用途，std::copy应该（如下面的Cheers所指出的）和memmove一样慢，因为无法保证内存区域会重叠。这意味着你可以非常容易地复制非连续区域（因为它支持迭代器）（想想稀疏分配的结构，如链表等......甚至是实现迭代器的自定义类/结构）。 memcpy仅适用于连续的原因，因此可以进行大量优化。
答案 3 :(得分：3)
这不是我得到的结果：
> 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
答案 4 :(得分：0)
根据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复制数据，但出于某种原因，未进行进一步内联 - 这就是性能差异的原因。
顺便说一下，Clang 3.4为两种情况生成相同的代码：
movl (%r14,%rbx), %ebp
答案 5 :(得分：0)
编辑：我将这个答案留作参考，使用gcc的奇怪时间似乎是“代码对齐”的产物（请参见评论）
我要说的是，这在当时的gcc 4中是一个实现故障，但是可能比这更复杂。 我的结果是（用于计数器的20000/20000）：
$ g++ -Ofast a.cpp; ./a.out
cast: 24 ms
memcpy: 47 ms
memmove: 24 ms
std::copy: 24 ms
(counter: 1787289600)
$ g++ -O3 a.cpp; ./a.out
cast: 24 ms
memcpy: 24 ms
memmove: 24 ms
std::copy: 47 ms
(counter: 1787289600)
$ g++ --version
g++ (Ubuntu 9.2.1-9ubuntu2) 9.2.1 20191008
请注意，使用copy和memcpy进行编译时，-O3和-Ofast的结果如何交换。同样，memmove也不比这两者都要慢。
在clang中，结果更简单：
$ clang++ -O3 a.cpp; ./a.out
cast: 26 ms
memcpy: 26 ms
memmove: 26 ms
std::copy: 26 ms
(counter: 1787289600)
$ clang++ -Ofast a.cpp; ./a.out
cast: 26 ms
memcpy: 26 ms
memmove: 26 ms
std::copy: 26 ms
(counter: 1787289600)
$ clang++ --version
clang version 9.0.0-2 (tags/RELEASE_900/final)