А такие вещи как memcpy/memmove очень сложно написать на высокоуровневом языке так, чтобы компилятор смог бы сгенерить код, который выжмет максимум пропускной способности. Но дело ведь не только в пропускной способности, но и в latency: memcpy/memmove может вызываться много-много раз на мелких кусках памяти, и если каждый раз они будут тупить, выбирая наилучшую стратегию копирования, то всё равно получится плохо.То есть, это выглядит примерно так:
int memcpy(void* src, void *dst, size_t size) {
const size_t block_size = 8;
const size_t unroll_count = 4;
size_t count = size / (block_size * unroll_count); // тут лучше shift'ами естественно, но можно надеятся компиль справится.
size_t rem = (size / block_size) % unroll_count;
size_t n = 0;
switch(rem) {
case 0: goto first; // я не совсем уверен, что любой компилятор C на любой платформе позволяет входить в цикл таким образом.
case 1: goto fourth;
case 2: goto third;
case 3: goto second;
}
for(; n < count; n ++) {
first:
*(uint64_t*)dst = *(uint64_t*)src;
src += block_size; // кстати, я не помню что там стандарт C говорит об арифметике на void*, может стоит преобразовать к char*, хотя gcc вроде умеет, делая вид, что размер void -- 1 байт.
dst += block_size;
second:
*(uint64_t*)dst = *(uint64_t*)src;
src += block_size;
dst += block_size;
third:
*(uint64_t*)dst = *(uint64_t*)src;
src += block_size;
dst += block_size;
fourth:
*(uint64_t*)dst = *(uint64_t*)src;
src += block_size;
dst += block_size;
}
// ах да, надо ещё для return'а сосчитать сколько скопировано...
}
Ну так вот, и это базовая имплементация. Тут ещё надо обработать случаи, когда size < block_size. Реальная имплементация, при этом, может, например, использовать регистры SSE или AVX для того, чтобы копировать (потому что они большие), то есть тебе придётся компиляторные builtin'ы подключать. С memmove ещё забавнее, потому как в зависимости от того, что и куда копируется, надо иногда копировать от начала к концу, иногда от конца к началу, а иногда лучше вызвать fallback'ом memcpy.
Ах и да, эта имплементация не везде сработает: она точно будет работать, если src и dst выровнены на границу кратную 8 байтам, но на некоторых платформах она может начать тормозить, если они не выровнены, или даже вообще откажется работать. Если использовать всякие там SSE и AVX, то точно начнёт тупить или не работать, в зависимости от того какие builtin'ы ты использовал. То есть надо ещё проверить выровненность и в зависимости от того, что там с ней, либо выровнять адреса, скопировав пару байт каким-нибудь тупым образом, либо копировать с невыровненного в выровненный или с выровненного в невыровненный. Короче, писать такое на C -- себе дороже. Проще написать на ассемблере. А поскольку memcpy используется во все поля, то и забить на его оптимизацию -- не вариант.
Но я всё это к тому, что если ты напишешь что-то в стиле:
char *dst = (char*)dst;
char *src = (char*)src;
for(i = 0; i < size; i ++)
(*dst++) = (*src++);
то компилятор C совершенно точно не будет тебе генерить простыни машинного кода наилучшей реализации memcpy под данную платформу.
