Compreendendo a diferença de tempo de duas funções que incrementam cada elemento de uma matriz de inteiros

No código colado abaixo, estou executando duas funções f1and f2que realizam exatamente o mesmo trabalho. Pegue um Tarray de números e inteiros arr(que foi inicializado para 0everywhere) e então incremente Tvezes cada elemento de arr Assim, no final de ambos f1e f2, a entrada 0,0...0deve se tornar T,T...T.

O que eu não entendo é por que f1roda muito mais devagar do que f2(cerca de 1,76 vezes mais lento quando Té, digamos, 1 bilhão). Aqui está minha saída

➜ Diferença de tempo do gcc para desktop.c && ./a.out 1000000000 16

-----> Executando f1 <------- Tempo gasto: 15,511 segundos

-----> Executando f2 <------- Tempo gasto: 8,887 segundos%

Aqui Té fornecido ao programa como argv[1]e o comprimento do array como argv[2]. O timing-difference.carquivo é colado abaixo no final deste post.

Basicamente, f1é incrementar diretamente cada arr[i], enquanto f2usa uma variável temporária tmppara o incremento e, em seguida, atribui-la a arr[i] quando terminar.

#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<time.h>

/*Directly increment arr[i] for each i*/
void f1(int T, int* arr, int arrlength){

  printf("\n-----> Running f1 <-------\n");
  clock_t end, start;
  double cpu_time_used;

  // For each element of arr, increment it T times.
  start = clock();
  for(int i = 0 ;  i<arrlength ;++i){
    for (int j=0 ; j<T ; ++j){
      arr[i] += 1;
    }
  }
  end = clock();
  cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; 

  printf("Time taken: %.3f seconds", cpu_time_used);

}

/*increment arr[i] using temporary variable tmp*/
void f2(int T, int* arr, int arrlength){

  printf("\n-----> Running f2 <-------\n");
  clock_t end, start;
  double cpu_time_used;

  // For each element of arr, increment it T times.
  start = clock();
  for(int i = 0 ;  i<arrlength ;++i){

    int tmp=arr[i];
    for (int j=0 ; j<T ; ++j){
      tmp += 1;
    }
    arr[i] = tmp; 
  }

  end = clock();
  cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC; 
  printf("Time taken: %.3f seconds", cpu_time_used);

}

void print_arr(int* arr, int arrlength){
  for(int i = 0 ; i<arrlength ; ++i){
    printf("%d  ", arr[i]);
  }
  printf("\n\n");

}

/*Zero initialize array*/
void initialize_array(int* arr, int arrlength){
  for (int i=0 ; i<arrlength ; ++i){
    arr[i] = 0;
  }

}

int main(int argc, char** argv){

  int T         = atoi(argv[1]);
  int arrlength = atoi(argv[2]);
  int arr[arrlength];
  
  initialize_array(arr, arrlength);
  f1(T,arr,arrlength);  // --> why does this run slower than f2?
  //print_arr(arr, arrlength);
    
  printf("\n\n");

  initialize_array(arr, arrlength);
  f2(T,arr,arrlength); 
  //print_arr(arr, arrlength);
  
  return 0;
}

EDIT : Eu obtenho as mesmas medições de tempo quando chamof2primeiro ef1depois ou mesmo se eu executo várias vezes.

Com -O2 habilitado, obtenho os timings como 0,000 em ambos. Fiquei curioso sobre as configurações padrão que o gcc estava usando para compilar e por que havia uma diferença tão grande no desempenho. A resposta, como wohlstad sugere, deve estar no assembly, mas, infelizmente, não consigo ler o assembly x86 bem :-( para um entendimento informado