memcpy：GCC 还是实现优化？

Question

Regarding writing an own memcpy function for a custom bootloader and kernel, I decided to look into the various aspects of writing a good and possibly fast implementation for copying memory on aligned boundaries (eg, scrolling in video mode, where each line on the screen is starting on an aligned boundary), but also for large (> 1 MB) and unaligned structures.

My question is, since the compiler, GCC in my case, does support a variety of optimization options (either by enabling the individual options or by using O2 , O3 , ...), to what level of optimization do I need to implement the actual memcpy function to achieve the best result when copying, together with the GCC optimization flags?

My current implementation is the following:

static void *memcpy_unaligned(void *dst, const void *src, size_t len)
{
    size_t i;
    unsigned char *d = (unsigned char *)dst;
    unsigned char *s = (unsigned char *)src;

    for (i = 0; i < len; i++)
        d[i] = s[i];

    return dst; 
}

static void *memcpy_aligned16(void *dst, const void *src, size_t len)
{
    size_t i;
    uint16_t *d = (uint16_t *)dst;
    uint16_t *s = (uint16_t *)src;

    for (i = 0; i < ((len) & (~1)); i += 2)
        d[i] = s[i];

    for ( ; i < len; i++)
        ((unsigned char *)d)[i] = ((unsigned char *)s)[i];

    return dst;
}

static void *memcpy_aligned32(void *dst, const void *src, size_t len)
{
    size_t i;
    uint32_t *d = (uint32_t *)dst;
    uint32_t *s = (uint32_t *)src;

    for (i = 0; i < ((len) & (~3)); i += 4)
        d[i] = s[i];

    for ( ; i < len; i++)
        ((unsigned char *)d)[i] = ((unsigned char *)s)[i];

    return dst;
}

static void *memcpy_aligned(void *dst, const void *src, size_t len)
{
    /* Are dst and src aligned on a 4-byte boundary? */
    if (ALIGNED(dst, src, 4))
        return memcpy_aligned32(dst, src, len);

    /* Are dst and src aligned on a 2-byte boundary? */
    if (ALIGNED(dst, src, 2))
        return memcpy_aligned16(dst, src, len);

    return memcpy_unaligned(dst, src, len);
}

void* memcpy(void *dst, const void *src, size_t len)
{
    return memcpy_aligned(dst, src, len);
}

Is it also useful to check if the dst and the src pointers are aligned at odd boundaries for only the first or first three bytes, in order to do a single-byte copy first, followed by word and dword copying?

Answer 1

Is it also useful to check if the dst and the src pointers are aligned at odd boundaries for only the first or first three bytes, in order to do a single-byte copy first, followed by word and dword copying?

Profiling for such matters, yet get the function right first.

OP's code has functional errors.

• OP original code is increasing index too fast
• Note: (len) & (~3) may incorrectly mask on rare non-2's complement

Use restrict to allow additional optimizations. Note: memcpy() is UB when buffers overlap.

static void *memcpy_aligned32(void * restrict dst, const void *restrict src, size_t len) {
  size_t i;
  // Casts not needed.  Do not cast away const-ness
  uint32_t *d = dst;
  const uint32_t *s = src;  

  size_t l4 = len/4;
  for (i = 0; i < l4; i++) {
    d[i] = s[i];
  }

  i *= 4;
  for ( ; i < len; i++) {
    ((unsigned char *)d)[i] = ((unsigned char *)s)[i]; // I'd use `uint8_t*` for symmetry
  }  

  return dst;
}

Perhaps additional AA issues apply.