C++ Tableau vs Vecteur de test de performance de l'explication [fermé]

afin de quantifier la différence de performance d'un C-tableau et les Vecteurs en C++, j'ai écrit ce petit programme. https://github.com/rajatkhanduja/Benchmarks/blob/master/C%2B%2B/vectorVsArray.cpp

pour les comparer sur des bases communes, j'ai décidé de tester à la fois l'accès aléatoire et séquentiel. J'ai ajouté des itérateurs, juste pour les comparer aussi (mais ce n'est pas ce sur quoi la question se concentre).

les résultats, pour une machine Linux 64-bit avec 7,7 Go de RAM avec sur un tableau / vecteur taille de 1 million sont les suivants: -

• Temps consacré à l'écriture à la matrice. : 12.0378 ms
• temps de lecture séquentielle du tableau. : 2.48413 ms
• temps pris pour lire à partir du tableau au hasard. : 37.3931 ms
• temps d'écriture sur dynamic array. : 11.7458 ms
• temps de lecture du dynamic array séquentiel. : 2.85107 ms
• temps de lecture aléatoire à partir d'un tableau dynamique. : 36.0579 ms
• Temps consacré à l'écriture de vecteur à l'aide d'indices. : 11.3909 ms
• a pris le Temps de lire à partir de vecteur à l'aide d'indices, de manière séquentielle. : 4.09106 ms
• temps de lecture du vecteur à l'aide d'indices aléatoires. : 39 ms
• temps nécessaire pour écrire au vecteur en utilisant des itérateurs. : 24.9949 ms
• temps de lecture du vecteur à l'aide d'itérateurs. : 18.8049 ms

la taille du vecteur est définie au moment de l'initialisation et non modifiée, de sorte qu'il n'y a pas de redimensionnement du vecteur (l'affirmation dans le programme aide à vérifier cela). Les temps n'incluent pas les temps d'initialisation de l'un des tableaux alloués statiquement, du tableau alloué dynamiquement ou du vecteur.

Selon les statistiques, le temps d'écrire à Vecteur est plus petit que celui du tableau mais le temps de lire à partir du vecteur est deux fois plus que celui du tableau.

la différence est assez faible, mais y a-t-il une explication à la différence de rendement ? Quelque chose ne va pas avec le test ? Je m'attendais à la fois pour effectuer à la même vitesse. La répétition de ce test montre la même tendance.

le code:

#include <vector>
#include <iostream>
#include <cstdlib>
#include <ctime>
#include <sys/time.h>
#include <cassert>

#define ARR_SIZE 1000000

using std::string;

void printtime (struct timeval& start, struct timeval& end, string str);   

int main (void)
{
  int arr[ARR_SIZE];
  int tmp;
  struct timeval start, stop;

  srand (time (NULL));

  /* Writing data to array */
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    arr[i] = rand();
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to write to array."));

  /* Reading data from array */
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = arr[i];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from array sequentially."));

  /* Reading data from array randomly*/
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = arr[rand() % ARR_SIZE];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from array randomly."));


  int *darr = (int *) calloc (sizeof (int), ARR_SIZE);  

  /* Writing data to array */
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    darr[i] = rand();
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to write to dynamic array."));

  /* Reading data from array */
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = darr[i];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from dynamic array sequentially."));

  /* Reading data from dynamic array randomly*/
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = darr[rand() % ARR_SIZE];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from dynamic array randomly."));

  std::vector<int> v(ARR_SIZE);
  assert (v.capacity() == ARR_SIZE);

  /* Writing to vector using indices*/
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    v[i] = rand();
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to write to vector using indices."));
  assert (v.capacity() == ARR_SIZE);

  /* Reading from vector using indices*/
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = v[i];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from vector using indices, sequentially."));

  /* Reading data from dynamic array randomly*/
  gettimeofday (&start, NULL);
  for (int i = 0; i < ARR_SIZE; i++)
  {
    tmp = v[rand() % ARR_SIZE];
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from vector using indices, randomly."));

  std::vector<int> v2(ARR_SIZE);

  /* Writing to vector using iterators*/
  gettimeofday (&start, NULL);
  std::vector<int>::iterator itr, itr_end;
  for (itr = v2.begin(), itr_end = v2.end(); itr != itr_end; itr++)
  {
    *itr = rand();
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to write to vector using iterators."));


  /* Reading from vector using iterators*/
  gettimeofday (&start, NULL);
  for (itr = v2.begin(), itr_end = v2.end(); itr != itr_end; itr++)
  {
    tmp = *itr;
  }
  gettimeofday (&stop, NULL);
  printtime (start, stop, string ("Time taken to read from vector using iterators."));

  return 0;
}

void printtime (struct timeval& start, struct timeval& end, string str)
{
  double start_time, end_time, diff;

  start_time = ((start.tv_sec) * 1000 + start.tv_usec/1000.0);
  end_time   = ((end.tv_sec) * 1000 + end.tv_usec/1000.0);
  diff = end_time - start_time;

  std::cout << str << " : " << diff << " ms" << std::endl;
}

---

modifier

Comme suggéré dans les commentaires, voici plus d'informations :-

• compilateur: - g++ - 4.5.2
• Flags": aucun (c'est à dire les valeurs par défaut)
• optimisations :- Aucune (je voulais tester le comportement dans un cadre habituel. L'optimisation peut varier le comportement du programme, par exemple puisque la variable tmp n'est jamais utilisée, l'étape de lecture du vecteur/tableau peut être complètement sautée ou réduit à la dernière mission. Au moins, c'est ce que je comprends).