为什么memcpy（）和memmove（）比指针增量快？

我复制从N个字节pSrc来pDest。这可以在一个循环中完成：

for (int i = 0; i < N; i++)
    *pDest++ = *pSrc++

为什么这比memcpyor 慢memmove？他们使用什么技巧来加快速度？

因为memcpy使用字指针而不是字节指针，所以memcpy实现也经常用SIMD指令编写，这使得可以一次重排128位。

SIMD指令是汇编指令，可以对最长16个字节的向量中的每个元素执行相同的操作。其中包括加载和存储指令。

内存复制例程比通过指针的简单内存复制要复杂得多，而且速度更快：

void simple_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;
  for (int i = 0; i < bytes; ++i)
    *b_dst++ = *b_src++;
}

改进之处

可以做的第一个改进是将一个指针对齐到字边界上（按字我的意思是本机整数大小，通常为32位/ 4字节，但在较新的体系结构上可以为64位/ 8字节），并使用字大小的移动/复制说明。这需要使用字节到字节的复制，直到指针对齐为止。

void aligned_memory_copy(void* dst, void* src, unsigned int bytes)
{
  unsigned char* b_dst = (unsigned char*)dst;
  unsigned char* b_src = (unsigned char*)src;

  // Copy bytes to align source pointer
  while ((b_src & 0x3) != 0)
  {
    *b_dst++ = *b_src++;
    bytes--;
  }

  unsigned int* w_dst = (unsigned int*)b_dst;
  unsigned int* w_src = (unsigned int*)b_src;
  while (bytes >= 4)
  {
    *w_dst++ = *w_src++;
    bytes -= 4;
  }

  // Copy trailing bytes
  if (bytes > 0)
  {
    b_dst = (unsigned char*)w_dst;
    b_src = (unsigned char*)w_src;
    while (bytes > 0)
    {
      *b_dst++ = *b_src++;
      bytes--;
    }
  }
}

根据源指针或目标指针是否正确对齐，不同的体系结构将执行不同的操作。例如，在XScale处理器上，通过对齐目标指针而不是源指针，我获得了更好的性能。

为了进一步提高性能，可以执行一些循环展开操作，以便将更多数据加载到处理器的寄存器中，这意味着可以对加载/存储指令进行交织，并通过其他指令（例如循环计数等）隐藏其延迟。由于加载/存储指令的等待时间可能完全不同，因此处理器带来的好处差别很大。

在此阶段，由于需要手动放置加载和存储指令以获得延迟隐藏和吞吐量的最大好处，因此代码最终以汇编语言而不是C（或C ++）语言编写。

通常，应在展开循环的一次迭代中复制整个缓存行数据。

这带来了我的下一个改进，增加了预取。这些是特殊的指令，它们告诉处理器的缓存系统将内存的特定部分加载到其缓存中。由于在发出指令与填充高速缓存行之间存在延迟，因此需要以这样的方式放置指令，以便在复制数据时就可以使用该数据，并且不再早/晚。

这意味着将预取指令放在函数的开头以及主复制循环中。通过复制循环中间的预取指令，可以获取将在多个迭代时间内复制的数据。

我不记得了，但是预取目标地址和源地址也可能会有所帮助。

因素

影响可以快速复制内存的主要因素有：

• 处理器，其缓存和主内存之间的等待时间。
• 处理器的缓存行的大小和结构。
• 处理器的内存移动/复制指令（等待时间，吞吐量，寄存器大小等）。

因此，如果您想编写一个高效，快速的内存处理例程，则需要了解很多有关要编写的处理器和体系结构的信息。可以说，除非您在某个嵌入式平台上进行编写，否则仅使用内置的内存复制例程会容易得多。

memcpy可以一次复制多个字节，具体取决于计算机的体系结构。大多数现代计算机可以在单个处理器指令中使用32位或更多位。

从一个示例实现中：

    00026 *为了快速进行复制，请优化两个指针均处于常见状态
    00027 *和长度按字对齐，然后一次复制一个字
    一次字节00028 *。否则，按字节复制。

您可以memcpy()使用以下任何一种技术来实现，其中一些技术取决于您的体系结构以提高性能，并且它们都比您的代码快得多：

1. 使用较大的单位，例如32位字而不是字节。您也可以在这里（或可能必须）处理对齐问题。例如，在某些平台上，您无法将32位字读/写到奇数个内存位置，而在其他平台上，则要付出巨大的性能损失。要解决此问题，地址必须是4的整数倍。对于64位CPU，您可以将此地址最多扩展为64位，或者使用SIMD（单指令，多数据）指令（MMX，SSE等）将其提高到64位。

2. 您可以使用编译器可能无法从C优化的特殊CPU指令。例如，在80386上，可以使用“ rep”前缀指令+“ movsb”指令来移动N字节，方法是将N放入计数寄存器。好的编译器会为您完成此任务，但是您可能会缺少一个好的编译器。请注意，该示例往往不能很好地证明速度，但是与对齐+较大的单元指令结合使用时，它可能比某些CPU上的大多数其他命令都要快。

3. 循环展开 -在某些CPU上分支可能非常昂贵，因此展开循环可以减少分支的数量。这也是与SIMD指令和超大型单元结合使用的好技术。

例如，httpmemcpy：//www.agner.org/optimize/#asmlib 的实现能击败大多数（很少）。如果您阅读了源代码，它将包含大量的内联汇编代码，这些内联汇编代码可以提取上述三种技术，并根据您所运行的CPU选择哪些技术。

注意，也可以进行类似的优化来查找缓冲区中的字节。strchr()和朋友之间的交往往往比您手摇的同等速度快。.NET和Java尤其如此。例如，在.NET中，内置程序String.IndexOf()甚至比Boyer-Moore字符串搜索要快得多，因为它使用了上述优化技术。

简短答案：

• 缓存填充
• 在可能的情况下使用字大小转移而不是字节转移
• SIMD魔术

我不知道它是否真正用于的任何实际实现中memcpy，但我认为Duff的设备在这里值得一提。

从维基百科：

send(to, from, count)
register short *to, *from;
register count;
{
        register n = (count + 7) / 8;
        switch(count % 8) {
        case 0:      do {     *to = *from++;
        case 7:              *to = *from++;
        case 6:              *to = *from++;
        case 5:              *to = *from++;
        case 4:              *to = *from++;
        case 3:              *to = *from++;
        case 2:              *to = *from++;
        case 1:              *to = *from++;
                } while(--n > 0);
        }
}

请注意，上述内容不是memcpy因为它故意不增加to指针。它执行的操作略有不同：将其写入内存映射寄存器。有关详细信息，请参见Wikipedia文章。

像其他人一样，memcpy复制大于1字节的块。以单词大小的块进行复制要快得多。但是，大多数实现会更进一步，并在循环之前运行多条MOV（字）指令。例如，每个循环复制8个字块的好处是循环本身很昂贵。该技术将条件分支的数量减少了8倍，优化了巨型块的副本。

答案很好，但是如果您仍然想memcpy自己实现斋戒，那么有一篇有趣的博客文章关于斋戒，C中的斋戒。

void *memcpy(void* dest, const void* src, size_t count)
{
    char* dst8 = (char*)dest;
    char* src8 = (char*)src;

    if (count & 1) {
        dst8[0] = src8[0];
        dst8 += 1;
        src8 += 1;
    }

    count /= 2;
    while (count--) {
        dst8[0] = src8[0];
        dst8[1] = src8[1];

        dst8 += 2;
        src8 += 2;
    }
    return dest;
}

甚至，优化内存访问也会更好。

因为像许多库例程一样，它已针对正在运行的体系结构进行了优化。其他人已经发布了可以使用的各种技术。

如果有选择，请使用库例程，而不要自己动手。这是DRY的一种变体，我称之为DRO（请勿重复其他内容）。而且，与您自己的实现相比，库例程不太可能出错。

我已经看到内存访问检查器抱怨内存或字符串缓冲区的读取超出范围，这不是字长的倍数。这是使用优化的结果。

您可以查看memset，memcpy和memmove的MacOS实现。

在启动时，操作系统确定运行的处理器。它为每个受支持的处理器内置了经过专门优化的代码，并且在启动时将jmp指令存储到正确的代码中固定的只读/只读位置。

C memset，memcpy和memmove实现只是跳转到该固定位置。

这些实现使用不同的代码，具体取决于memcpy和memmove的源和目标的对齐方式。他们显然使用了所有可用的向量功能。当您复制大量数据时，它们还使用非缓存变量，并具有减少页表等待的说明。这不仅仅是汇编代码，它是由对每种处理器体系结构非常了解的人编写的汇编代码。

英特尔还增加了汇编程序指令，可以使字符串操作更快。例如，使用一条支持strstr的指令在一个周期内执行256字节比较。