Performance de différents containers de la stl

Soyez le premier à donner votre avis sur cette source.

Snippet vu 3 318 fois - Téléchargée 18 fois

Contenu du snippet

Programme montrant les différences de performances entre certains containers
de la stl
Les containers testés sont les suivants :
- std::vector
- std::list
- std::stack
- std::queue
Pour l'instant, seulement les fonctions suivantes sont testés :
- Ajout d'un élément en fin
- Suppression d'un élément en fin

Protocole de test :
- Appel de la fonction NB_ITERATION fois

Informations :
- NB_ITERATION doit être assez grand (dépend de la puissance de la machine)
pour que les valeurs soient significatives

Améliorations :
- Tester plus de containers et plus de fonctions

Source / Exemple :


/**

  • Programme montrant les différences de performances entre certains containers
  • de la stl
  • Les containers testés sont les suivants :
  • - std::vector
  • - std::list
  • - std::stack
  • - std::queue
  • Pour l'instant, seulement les fonctions suivantes sont testés :
  • - Ajout d'un élément en fin
  • - Suppression d'un élément en fin
*
  • Protocole de test :
  • - Appel de la fonction NB_ITERATION fois
*
  • Informations :
  • - NB_ITERATION doit être assez grand (dépend de la puissance de la machine)
  • pour que les valeurs soient significatives
  • Améliorations :
  • - Tester plus de containers et plus de fonctions
  • /
#include <vector> #include <list> #include <iostream> #include <queue> #include <time.h> #include <typeinfo> #include <stack> using namespace std; static clock_t start, finish; static double duration; static int NB_ITERATION = 0; /**
  • Appel de la fonction NB_ITERATION fois
  • /
double getFunctionDuration(void (*pt2Function)(void* pt2Object, int parameter), void * object) { start = clock(); for (int i = 0; i < NB_ITERATION; i++) (*pt2Function)(object, i); finish = clock(); return (double)(finish - start) / CLOCKS_PER_SEC; } template <class T> static void wrapper_for_push_back(void * container, int parameter) { T * casted_container = (T*) container; casted_container->push_back(parameter); } template <typename T> static void wrapper_for_push(void * container, int parameter) { T * casted_container = (T*) container; casted_container->push(parameter); } template <typename T> static void wrapper_for_pop_back(void * container, int parameter) { T * casted_container = (T*) container; casted_container->pop_back(); } template <typename T> static void wrapper_for_pop(void * container, int parameter) { T * casted_container = (T*) container; casted_container->pop(); } int main() { cout << " Iteration times = "; cin >> NB_ITERATION; std::vector<int> v; std::list<int> l; std::queue<int> q; std::stack<int> s; // Tests des insertions en fin cout << "push_back vector = " << getFunctionDuration(wrapper_for_push_back<std::vector<int>>, &v) << endl; cout << "push_back list = " << getFunctionDuration(wrapper_for_push_back<std::list<int>>, &l) << endl; cout << "push queue = " << getFunctionDuration(wrapper_for_push<std::queue<int>>, &q) << endl; cout << "push stack = " << getFunctionDuration(wrapper_for_push<std::stack<int>>, &s) << endl; // Tests des suppression en fin cout << "pop_back vector = " << getFunctionDuration(wrapper_for_pop_back<std::vector<int>>, &v) << endl; cout << "pop_back list = " << getFunctionDuration(wrapper_for_pop_back<std::list<int>>, &l) << endl; cout << "pop queue = " << getFunctionDuration(wrapper_for_pop<std::queue<int>>, &q) << endl; cout << "pop stack = " << getFunctionDuration(wrapper_for_pop<std::stack<int>>, &s) << endl; cin.get(); }

A voir également

Ajouter un commentaire Commentaires
Messages postés
2
Date d'inscription
dimanche 10 octobre 2010
Statut
Membre
Dernière intervention
31 mai 2011

Effectivement je vois que j'ai encore des progrès à faire...
Pour ce qui est du using namespace std, je pensais que les erreurs qui pouvaient en découler était marginales, mais en lisant l'article, pas tant que ça en fait...
Pour les variables globales et l'usage de static, c'est un oubli de ma part, je voulais les enlever, mais merci pour l'info du namespace anonyme.
Sinon merci beaucoup pour la correction.
Messages postés
229
Date d'inscription
dimanche 14 septembre 2003
Statut
Membre
Dernière intervention
20 août 2014

Bon code de débutant (avec les erreurs qui vont avec).
Suis les conseils de CptPingu, plus tôt tu évites les mauvaises pratiques, mieux ce sera par la suite
Messages postés
3839
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
15 avril 2021
120
- Évite les "using namespace", voir: http://0217021.free.fr/portfolio/axel.berardino/articles/bon-usage-using-namespace
- Évite les void*, ça n'a rien à faire en C++. Tu peux les éviter avec de l'héritage ou des templates.
- Évite les variables globales
- En C++, on utilise un namespace anonyme et non plus le mot clé "static".
- clock n'est pas très précis

Je te propose une version pure C++:

#ifndef SCOPEELAPSEDTIME_HH_
# define SCOPEELAPSEDTIME_HH_

# include
# include <sstream>
# include <ctime>
# include <sys/time.h>

class ScopeElapsedTime
{
public:
ScopeElapsedTime()
: origin_("")
{
gettimeofday(&begin_, &tz_);
}

ScopeElapsedTime(const std::string& origin)
: origin_(origin)
{
gettimeofday(&begin_, &tz_);
}

~ScopeElapsedTime()
{
std::ostringstream buff;
gettimeofday(&end_, &tz_);
long time = (end_.tv_sec - begin_.tv_sec) *
1000000L + (end_.tv_usec - begin_.tv_usec);
if (!origin_.empty())
buff << "[" << origin_ << "]";
buff << "Elapsed time: " << time << " us";

std::cout << buff.str() << std::endl;
}

private:
std::string origin_;
struct timeval begin_, end_;
struct timezone tz_;
};

#endif /* !SCOPEELAPSEDTIME_HH_ */

#include
#include <vector>
#include <list>
#include <queue>
#include <stack>

namespace
{
template <typename Container, typename Type>
struct Func
{
typedef void (*pFunc) (Container& container, const Type& parameter);
};

template <typename Container, typename Type>
void push(Container& container, const Type& parameter)
{
container.push_back(parameter);
}

template <typename Type>
void push(std::queue<Type>& container, const Type& parameter)
{
container.push(parameter);
}

template <typename Type>
void push(std::stack<Type>& container, const Type& parameter)
{
container.push(parameter);
}

template <typename Container, typename Type>
void pop(Container& container, const Type&)
{
container.pop_back();
}

template <typename Type>
void pop(std::queue<Type>& container, const Type&)
{
container.pop();
}

template <typename Type>
void pop(std::stack<Type>& container, const Type&)
{
container.pop();
}

template <typename Container, typename Type>
void wrapperShowFunctionDuration(Container& v, const Type& t, int nb_iteration,
const std::string& name, typename Func<Container, Type>::pFunc func)
{
ScopeElapsedTime timer(name);
for (int i = 0; i < nb_iteration; ++i)
func(v, t);
}

template <typename Container, typename Type>
void showFunctionDuration(Container& v, int nb_iteration, const std::string& name, typename Func<Container, Type>::pFunc func)
{
const Type t = Type();
wrapperShowFunctionDuration(v, t, nb_iteration, name, func);
}
}

int main()
{
ScopeElapsedTime timer("Global");
int nb_iteration = 0;
std::cout << " Iteration times = ";
std::cin >> nb_iteration;

std::vector v;
std::list l;
std::queue q;
std::stack s;

showFunctionDuration<std::vector, int>(v, nb_iteration, "Push Vector", push<std::vector, int>);
showFunctionDuration<std::list, int>(l, nb_iteration, "Push List", push<std::list, int>);
showFunctionDuration<std::queue, int>(q, nb_iteration, "Push Queue", push);
showFunctionDuration<std::stack, int>(s, nb_iteration, "Push Stack", push);

showFunctionDuration<std::vector, int>(v, nb_iteration, "Pop Vector", pop<std::vector, int>);
showFunctionDuration<std::list, int>(l, nb_iteration, "Pop List", pop<std::list, int>);
showFunctionDuration<std::queue, int>(q, nb_iteration, "Pop Queue", pop);
showFunctionDuration<std::stack, int>(s, nb_iteration, "Pop Stack", pop);

return 0;
}

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.