¿Por qué memcpy () y memmove () son más rápidos que los incrementos de puntero?

Estoy copiando N bytes de pSrca pDest. Esto se puede hacer en un solo ciclo:

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

¿Por qué es más lento que memcpyo memmove? ¿Qué trucos usan para acelerarlo?

Debido a que memcpy usa punteros de palabras en lugar de punteros de bytes, también las implementaciones de memcpy a menudo se escriben con instrucciones SIMD que hacen posible mezclar 128 bits a la vez.

Las instrucciones SIMD son instrucciones de ensamblaje que pueden realizar la misma operación en cada elemento de un vector de hasta 16 bytes de longitud. Eso incluye instrucciones de carga y almacenamiento.

Las rutinas de copia de memoria pueden ser mucho más complicadas y rápidas que una simple copia de memoria a través de punteros como:

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++;
}

Mejoras

La primera mejora que se puede hacer es alinear uno de los punteros en un límite de palabra (por palabra me refiero al tamaño entero nativo, generalmente 32 bits / 4 bytes, pero puede ser 64 bits / 8 bytes en arquitecturas más nuevas) y usar movimiento del tamaño de una palabra / copiar instrucciones. Esto requiere usar una copia de byte a byte hasta que se alinee un puntero.

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--;
    }
  }
}

Las diferentes arquitecturas se comportarán de manera diferente en función de si el puntero de origen o de destino está alineado correctamente. Por ejemplo, en un procesador XScale obtuve un mejor rendimiento alineando el puntero de destino en lugar del puntero de origen.

Para mejorar aún más el rendimiento, se puede realizar un desenrollado de bucles, de modo que más registros del procesador se carguen con datos y eso significa que las instrucciones de carga / almacenamiento se pueden intercalar y tener su latencia oculta por instrucciones adicionales (como el conteo de bucles, etc.). El beneficio que esto trae varía bastante según el procesador, ya que las latencias de instrucción de carga / almacenamiento pueden ser bastante diferentes.

En esta etapa, el código termina por escribirse en Ensamblador en lugar de C (o C ++), ya que debe colocar manualmente las instrucciones de carga y almacenamiento para obtener el máximo beneficio de la ocultación de latencia y el rendimiento.

Por lo general, se debe copiar una línea de datos de caché completa en una iteración del ciclo desenrollado.

Lo que me lleva a la siguiente mejora, la adición de búsqueda previa. Estas son instrucciones especiales que le dicen al sistema de caché del procesador que cargue partes específicas de la memoria en su caché. Dado que hay un retraso entre la emisión de la instrucción y el llenado de la línea de caché, las instrucciones deben colocarse de tal manera que los datos estén disponibles cuando se van a copiar, y no antes / después.

Esto significa poner instrucciones de captación previa al inicio de la función, así como dentro del bucle de copia principal. Con las instrucciones de captación previa en medio del ciclo de copia, se obtienen datos que se copiarán en varias iteraciones.

No lo recuerdo, pero también puede ser beneficioso obtener previamente las direcciones de destino y las de origen.

Factores

Los principales factores que afectan la rapidez con que se puede copiar la memoria son:

• La latencia entre el procesador, sus cachés y la memoria principal.
• El tamaño y la estructura de las líneas de caché del procesador.
• Las instrucciones de movimiento / copia de la memoria del procesador (latencia, rendimiento, tamaño de registro, etc.).

Por lo tanto, si desea escribir una rutina de manejo de memoria rápida y eficiente, necesitará saber bastante sobre el procesador y la arquitectura para los que está escribiendo. Es suficiente decir que, a menos que esté escribiendo en alguna plataforma integrada, sería mucho más fácil usar las rutinas de copia de memoria integradas.

memcpypuede copiar más de un byte a la vez dependiendo de la arquitectura de la computadora. La mayoría de las computadoras modernas pueden trabajar con 32 bits o más en una sola instrucción de procesador.

De una implementación de ejemplo :

    00026 * Para una copia rápida, optimice el caso común donde ambos punteros
    00027 * y la longitud están alineadas con las palabras y, en su lugar, se copian palabra por palabra
    00028 * de bytes a la vez. De lo contrario, copie por bytes.

Puede implementar memcpy()utilizando cualquiera de las siguientes técnicas, algunas de las cuales dependen de su arquitectura para mejorar el rendimiento, y todas serán mucho más rápidas que su código:

1. Utilice unidades más grandes, como palabras de 32 bits en lugar de bytes. También puede (o puede que tenga que) ocuparse de la alineación aquí. No puede leer / escribir una palabra de 32 bits en una ubicación de memoria extraña, por ejemplo, en algunas plataformas, y en otras plataformas paga una penalización masiva de rendimiento. Para solucionar este problema, la dirección debe ser una unidad divisible por 4. Puede tomar esto hasta 64 bits para CPU de 64 bits, o incluso más usando instrucciones SIMD (instrucción única, datos múltiples) ( MMX , SSE , etc.)

2. Puede usar instrucciones especiales de CPU que su compilador no pueda optimizar desde C. Por ejemplo, en un 80386, puede usar la instrucción de prefijo "rep" + instrucción "movsb" para mover N bytes dictados colocando N en el recuento Registrarse. Los buenos compiladores harán esto por usted, pero es posible que se encuentre en una plataforma que carece de un buen compilador. Tenga en cuenta que ese ejemplo tiende a ser una mala demostración de velocidad, pero combinado con alineación + instrucciones de unidad más grandes, puede ser más rápido que casi todo lo demás en ciertas CPU.

3. Desenrollado de bucles : las ramas pueden ser bastante caras en algunas CPU, por lo que desenrollar los bucles puede reducir el número de ramas. Esta también es una buena técnica para combinar con instrucciones SIMD y unidades de gran tamaño.

Por ejemplo, http://www.agner.org/optimize/#asmlib tiene una memcpyimplementación que supera a la mayoría (por una cantidad muy pequeña). Si lee el código fuente, estará lleno de toneladas de código ensamblador en línea que implementa todas las tres técnicas anteriores, eligiendo cuál de esas técnicas en función de la CPU en la que está ejecutando.

Tenga en cuenta que también se pueden realizar optimizaciones similares para buscar bytes en un búfer. strchr()y los amigos a menudo lo harán más rápido que su equivalente enrollado a mano. Esto es especialmente cierto para .NET y Java . Por ejemplo, en .NET, la función integrada String.IndexOf()es mucho más rápida que incluso una búsqueda de cadenas de Boyer-Moore , porque utiliza las técnicas de optimización anteriores.

Respuesta corta:

• relleno de caché
• transferencias de tamaño de palabras en lugar de bytes cuando sea posible
• Magia SIMD

No sé si realmente se usa en alguna implementación del mundo real memcpy, pero creo que el dispositivo de Duff merece una mención aquí.

De Wikipedia :

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);
        }
}

Tenga en cuenta que lo anterior no es un memcpyya que deliberadamente no incrementa el topuntero. Implementa una operación ligeramente diferente: la escritura en un registro mapeado en memoria. Consulte el artículo de Wikipedia para obtener más detalles.

Como otros dicen, memcpy copia más de 1 byte. Copiar en trozos del tamaño de una palabra es mucho más rápido. Sin embargo, la mayoría de las implementaciones van un paso más allá y ejecutan varias instrucciones MOV (palabra) antes del bucle. La ventaja de copiar, por ejemplo, 8 bloques de palabras por bucle es que el bucle en sí es costoso. Esta técnica reduce el número de ramas condicionales en un factor de 8, optimizando la copia para bloques gigantes.

Las respuestas son grandes, pero si todavía quiere implementar una rápida memcpyusted mismo, hay una entrada en el blog interesante de establecimiento de memoria rápida, establecimiento de memoria rápida en 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;
}

Incluso, puede ser mejor optimizando los accesos a la memoria.

Porque, como muchas rutinas de biblioteca, se ha optimizado para la arquitectura en la que se está ejecutando. Otros han publicado varias técnicas que se pueden utilizar.

Si tiene la opción, use las rutinas de la biblioteca en lugar de rodar las suyas. Esta es una variación de DRY que llamo DRO (Don't Repeat Others). Además, es menos probable que las rutinas de la biblioteca sean incorrectas que su propia implementación.

He visto que los verificadores de acceso a la memoria se quejan de lecturas fuera de los límites en la memoria o búferes de cadenas que no eran un múltiplo del tamaño de la palabra. Este es el resultado de la optimización que se está utilizando.

Puede ver la implementación de MacOS de memset, memcpy y memmove.

En el momento del arranque, el sistema operativo determina en qué procesador se está ejecutando. Ha incorporado un código específicamente optimizado para cada procesador compatible y, en el momento del arranque, almacena una instrucción jmp en el código correcto en una ubicación fija de solo lectura.

Las implementaciones de C memset, memcpy y memmove son solo un salto a esa ubicación fija.

Las implementaciones usan código diferente según la alineación de origen y destino para memcpy y memmove. Obviamente utilizan todas las capacidades vectoriales disponibles. También usan variantes sin almacenamiento en caché cuando copia grandes cantidades de datos y tienen instrucciones para minimizar las esperas de tablas de páginas. No es solo código ensamblador, es código ensamblador escrito por alguien con un conocimiento extremadamente bueno de la arquitectura de cada procesador.

Intel también agregó instrucciones de ensamblador que pueden acelerar las operaciones de cadenas. Por ejemplo, con una instrucción para admitir strstr que realiza comparaciones de 256 bytes en un ciclo.