Влияние конвейера на скорость исполнения кода

void
copy (int *dst, const int *src, unsigned long length)
{
  unsigned long i;
 
  for (i = 0; i < length; i++)
    dst[i] = src[i] + 1023;
}

void
copy (int *dst, const int *src, unsigned long length)
{
  unsigned long i;
 
  for (i = 0; i < length; i += 2)
    {
      int a, b, c, d;
      a = src[i];
      b = src[i+1];
      c = a + 1023;
      d = b + 1023;
      dst[i] = c;
      dst[i+1] = d;
    }
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
 
void
copy (int *dst, const int *src, unsigned long length)
{
 unsigned long i;
 
#if 1
  /* "Простой" вариант */
  for (i = 0; i < length; i++)
    dst[i] = src[i] + 1023;
#else
  /* Оптимизированный вариант */
  for (i = 0; i < length; i += 2)
    {
      int a, b, c, d;
      a = src[i];
      b = src[i+1];
      c = a + 1023;
      d = b + 1023;
      dst[i] = c;
      dst[i+1] = d;
    }
#endif
}
 
/* Вызов функции делаем через указатель, чтобы не было inline-подстановки.
 * На результат это практически не влияет, но без inline'а проще глазками
 * смотреть ассемблерный текст */
void (*copy_ptr)(int*, const int*, unsigned long) = copy;
 
/* Размер массива */
#define N 100000
 
/* Количество циклов копирования, входящих в задачу.
 * Казалось бы, что два параметра N и LOOP являются избыточными,
 * но это только кажется. Если сравнить 100 циклов по 1 мегабйту
 * и 1 цикл на 100 мегабайт, то мы получим разные результаты.
 * В первом случае объём обработанных данных, условно говоря, целиком
 * умещается в кэш, а во втором случае - нет. В первом случае будет
 * маленькая нагрузка на подсистему памяти, обслуживающую виртуальную
 * адресацию, а во втором случае - большая. Мы хотим померить "чистое"
 * время работы цикла, но не скорость работы подсистемы памяти */
#define LOOP 100000
 
/* Количество повторений задачи. Параметр тоже может показаться избыточным.
 * Но если увеличить значение N таким образом, чтобы оно заведомо превышало
 * размер кэша, (и в соответсвующее число раз уменьшить значение LOOP,
 * чтобы общее время работы было примерно такое же) то по результирующей
 * печати времени исполнения можно увидеть, что COUNT себя оправдывает.
 * В этом случае первые один-два запуска задачи будут работать на то,
 * чтобы "раскрутилась" подсистема памяти (и время работы будет иметь выброс),
 * а остальные запуски задачи уже будут давать более-менее справедливые
 * результаты */
#define COUNT 5
 
int
main (void)
{
 clock_t t1, t2;
 unsigned i, j;
 
 int *src = malloc (sizeof (int) * N);
 int *dst = malloc (sizeof (int) * N);
 
 for (i = 0; i < COUNT; i++)
   {
     t1 = clock();
     for (j = 0; j < LOOP; j++)
       copy_ptr (dst, src, N);
     t2 = clock();
 
     printf("time: %.03f\n", ((double)(t2 - t1))/CLOCKS_PER_SEC);
   }
 
 return 0;
}