Understanding the source code of memcpy()

Question

00018 void *memcpy(void *dst, const void *src, size_t len) 00019 { 00020         size_t i; 00021  00022         /* 00023          * memcpy does not support overlapping buffers, so always do it 00024          * forwards. (Don't change this without adjusting memmove.) 00025          * 00026          * For speedy copying, optimize the common case where both pointers 00027          * and the length are word-aligned, and copy word-at-a-time instead 00028          * of byte-at-a-time. Otherwise, copy by bytes. 00029          * 00030          * The alignment logic below should be portable. We rely on 00031          * the compiler to be reasonably intelligent about optimizing 00032          * the divides and modulos out. Fortunately, it is. 00033          */ 00034  00035         if ((uintptr_t)dst % sizeof(long) == 0 && 00036             (uintptr_t)src % sizeof(long) == 0 && 00037             len % sizeof(long) == 0) { 00038  00039                 long *d = dst; 00040                 const long *s = src; 00041  00042                 for (i=0; i<len/sizeof(long); i++) { 00043                         d[i] = s[i]; 00044                 } 00045         } 00046         else { 00047                 char *d = dst; 00048                 const char *s = src; 00049  00050                 for (i=0; i<len; i++) { 00051                         d[i] = s[i]; 00052                 } 00053         } 00054  00055         return dst; 00056 } 

I was just going through an implementation of memcpy, to understand how it differs from using a loop. But I couldn't see any difference between using a loop rather than memcpy, as memcpy uses loop again internally to copy.

I couldn't understand if part they do for integers — i < len/sizeof(long). Why is this calculation required?

Answer 1

I couldn't understand if part they do for integers. i < len/sizeof(long). Why is this calculation required ?

Because they are copying words, not individual bytes, in this case (as the comment says, it is an optimization - it requires less iterations and the CPU can handle word aligned data more efficiently).

len is the number of bytes to copy, and sizeof(long) is the size of a single word, so the number of elements to copy (means, loop iterations to execute) is len / sizeof(long).

Answer 2

to understand how it differs from using a loop. But I couldn't any difference of using a loop rather than memcpy, as memcpy uses loop again internally to copy

Well then it uses a loop. Maybe other implementations of libc doesn't do it like that. Anyway, what's the problem/question if it does use a loop? Also as you see it does more than a loop: it checks for alignment and performs a different kind of loop depending on the alignment.

I couldn't understand if part they do for integers. i < len/sizeof(long). Why is this calculation required ?

This is checking for memory word alignment. If the destination and source addresses are word-aligned, and the length copy is multiple of word-size, then it performs an aligned copy by word (long), which is faster than using bytes (char), not only because of the size, but also because most architectures do word-aligned copies much faster.