2

众所周知，在 x86/x86_64 等多字节字计算机中，逐字复制/移动大量内存（每步 4 或 8 个字节）比逐字节复制/移动更有效。

我很好奇 strncpy/memcpy/memmove 会以哪种方式做事，以及它们如何处理内存字对齐。

char buf_A[8], buf_B[8];

// I often want to code as this
*(double*)buf_A = *(double*)buf_B;

//in stead of this
strcpy(buf_A, buf_B);
// but it worsen the readability of my codes.
4

6 回答 6

5

一般来说，您不必过多考虑如何memcpy实现或其他类似功能。你应该假设它们是有效的，除非你的分析证明你错了。

在实践中，它确实得到了很好的优化。参见例如以下测试代码：

#include <cstring>

void test(char (&a)[8], char (&b)[8])
{
    std::memcpy(&a,&b,sizeof a);
}

用g++ 7.3.0 用命令编译它，g++ test.cpp -O3 -S -masm=intel我们可以看到如下汇编代码：

test(char (&) [8], char (&) [8]):

    mov     rax, QWORD PTR [rsi]
    mov     QWORD PTR [rdi], rax
    ret

如您所见，副本不仅是内联的，而且还折叠成单个 8 字节的读写。

于 2019-01-22T11:21:54.613 回答
3

在这种情况下，您可能更喜欢使用memcpy它，因为这相当于*(double*)buf_A = *(double*)buf_B;没有未定义的行为。

您不必担心调用memcpy，因为默认情况下编译器假定调用memcpy具有 c 库中定义的含义。因此，根据参数的类型和/或在编译时对副本大小的了解，编译器可能会选择不调用 c 库函数并内联更适合的内存复制策略。-fno-builtin在 gcc 上，您可以使用编译器选项禁用此行为： demo。

需要编译器替换 memcpy 调用，因为 memcpy 将检查指针的大小和对齐方式以使用最有效的内存复制策略（它可能会开始使用 AVX512 指令将小块（如 char by char）复制到非常大的块例子）。这些检查以及任何调用 memcpy 的费用。

此外，如果您正在寻找效率，您应该关注内存对齐。因此，您可能需要声明缓冲区的对齐方式：

alignas(8) char buf_A[8];
于 2019-01-22T11:51:59.447 回答
1

从cpp 参考：

将 count 字节从 src 指向的对象复制到 dest 指向的对象。两个对象都被重新解释为无符号字符数组。

笔记

std::memcpy 旨在成为内存到内存复制的最快库例程。它通常比 std::strcpy 更有效，后者必须扫描它复制的数据或 std::memmove，后者必须采取预防措施来处理重叠输入。

一些 C++ 编译器将合适的内存复制循环转换为 std::memcpy 调用。

在严格别名禁止检查同一内存作为两种不同类型的值的情况下，std::memcpy 可用于转换这些值。

所以它应该是复制数据的最快方法。但是请注意，有几种情况下行为未定义：

如果对象重叠，则行为未定义。

如果 dest 或 src 是空指针，则行为未定义，即使 count 为零。

如果对象可能重叠或不是 TriviallyCopyable，则未指定 memcpy 的行为并且可能未定义。

于 2019-01-22T10:51:51.233 回答
1

这取决于您使用的编译器和您使用的 C 运行时库。在大多数情况下，string.h 函数（如memcmp、memcpy、strcpu等memset）是使用汇编以 CPU 优化的方式实现的。

您可以为 AMD64 架构找到这些函数的 GNU libc 实现。如您所见，它可能使用 SSE 或 AVX 指令在每次迭代中复制 128 位和 512 位。Microsoft 还将其 CRT 的源代码与 Visual Studio 捆绑在一起（大多数方法相同，支持 MMX、SSE、AVX 循环）。

编译器还对此类函数使用特殊优化，GCC 将它们称为内置函数，其他编译器将它们称为固有函数。即编译器可以选择 - 调用库函数，或生成针对当前上下文最佳的 CPU 特定汇编代码。例如，当N参数memcpy是常量时，即memcpy(dst, src, 128)编译器可能会生成内联汇编代码（类似于mov 16,rcx cls rep stosq），而当它是变量时，即memcpy(dst,src,bytes)- 编译器可能会插入对库函数的调用（类似于call _memcpy）

于 2019-01-22T12:16:07.477 回答
1

strcpy/strncpy 是逐字节还是以其他有效方式复制数据？

C++ 和 C 标准没有具体说明 strcpy/strncpy 是如何实现的。他们只描述行为。

有多个标准库实现，每个都选择如何实现它们的功能。可以使用 memcpy 来实现这两个。标准也没有准确描述 memcpy 的实现，并且多个实现的存在也适用于它。

memcpy 可以利用全字复制来实现。如何实现memcpy 的简短伪代码：

if len >= 2 * word size
    copy bytes until destination pointer is aligned to word boundary
    if len >= page size
        copy entire pages using virtual address manipulation
    copy entire words
 copy the trailing bytes that are not aligned to word boundary

要了解特定标准库实现如何实现 strcpy/strncpy/memcpy，您可以阅读标准库的源代码 - 如果您可以访问它。

更进一步，当在编译时知道长度时，编译器甚至可能选择不使用库 memcpy，而是进行内联复制。您的编译器是否内置了标准库函数的定义，您可以在相应编译器的文档中找到。

于 2019-01-22T11:10:31.617 回答
0

我认为此页面上的所有意见和建议都是合理的，但我决定尝试一个小实验。

令我惊讶的是，最快的方法并不是我们理论上预期的方法。

我尝试了一些代码如下。

#include <cstring>
#include <iostream>
#include <string>
#include <chrono>

using std::string;
using std::chrono::system_clock;

inline void mycopy( double* a, double* b, size_t s ) {
   while ( s > 0 ) {
      *a++ = *b++;
      --s;
   }
};

// to make sure that every bits have been changed
bool assertAllTrue( unsigned char* a, size_t s ) {
   unsigned char v = 0xFF;
   while ( s > 0 ) {
      v &= *a++;
      --s;
   }
   return v == 0xFF;
};

int main( int argc, char** argv ) {
   alignas( 16 ) char bufA[512], bufB[512];
   memset( bufB, 0xFF, 512 );  // to prevent strncpy from stoping prematurely
   system_clock::time_point startT;

   memset( bufA, 0, sizeof( bufA ) );
   startT = system_clock::now();
   for ( int i = 0; i < 1024 * 1024; ++i )
      strncpy( bufA, bufB, sizeof( bufA ) );
   std::cout << "strncpy:" << ( system_clock::now() - startT ).count()
             << ", AllTrue:" << std::boolalpha
             << assertAllTrue( ( unsigned char* )bufA, sizeof( bufA ) )
             << std::endl;

   memset( bufA, 0, sizeof( bufA ) );
   startT = system_clock::now();
   for ( int i = 0; i < 1024 * 1024; ++i )
      memcpy( bufA, bufB, sizeof( bufA ) );
   std::cout << "memcpy:" << ( system_clock::now() - startT ).count()
             << ", AllTrue:" << std::boolalpha
             << assertAllTrue( ( unsigned char* )bufA, sizeof( bufA ) )
             << std::endl;

   memset( bufA, 0, sizeof( bufA ) );
   startT = system_clock::now();
   for ( int i = 0; i < 1024 * 1024; ++i )
      memmove( bufA, bufB, sizeof( bufA ) );
   std::cout << "memmove:" << ( system_clock::now() - startT ).count()
             << ", AllTrue:" << std::boolalpha
             << assertAllTrue( ( unsigned char* )bufA, sizeof( bufA ) )
             << std::endl;

   memset( bufA, 0, sizeof( bufA ) );
   startT = system_clock::now();
   for ( int i = 0; i < 1024 * 1024; ++i )
      mycopy( ( double* )bufA, ( double* )bufB, sizeof( bufA ) / sizeof( double ) );
   std::cout << "mycopy:" << ( system_clock::now() - startT ).count()
             << ", AllTrue:" << std::boolalpha
             << assertAllTrue( ( unsigned char* )bufA, sizeof( bufA ) )
             << std::endl;

   return EXIT_SUCCESS;
}

结果（许多类似结果之一）：

strncpy：52840919，AllTrue：真

memcpy：57630499，AllTrue：真

memmove：57536472，AllTrue：真

我的副本：57577863，AllTrue：真

看起来像：

  1. memcpy、memmove 和我自己的方法有类似的结果；
  2. strncpy 有什么魔力，所以它是最好的，甚至比 memcpy 还要快？

好笑吗？

于 2019-01-22T15:14:03.060 回答