Comparaison des performance d'algorithmes pour optimiser un code

Commenter

Contenu du snippet

Ce petit programme me permet de comparer les temps d'exécution d'algorithmes.

J'utilise la fonction QueryPerformanceCounter pour être le plus précis possible.
Le premier algo sert de temps de référence.
Ensuite, j'affiche l'écart de temps des autres algos en pourcentage (50% = 2x plus rapide / 100% = même vitesse / 200% = 2x plus lent)

Pour ne pas fausser les temps, je procède ainsi :
- je ferme toutes les applications risquant de surveiller les algos (anti-virus et firewall)
- je sélectionne le mode le plus rapide lors de la construction (mode 'Release')
- je lance le test en cliquant sur l'exe (et pas depuis Visual C++)

Dans l'exemple, je teste diverses méthodes d'écriture en boucle dans un vecteur.
Sur ma machine, la boucle est beaucoup plus performant avec l'opérateur [] qu'avec les fonctions membres begin() et end().

Je serais intéressé de connaître vos résultats pour d'autres algo comme les boucles for et while, l'usage de int ou long, ...

Source / Exemple : 


#include <iostream>
#include <vector>

#include <windows.h>
#include <conio.h>

using namespace std;

/* REMARQUE : Pour ne pas fausser les temps, suivez les conseils suivants :
- Sélectionnez le mode le plus rapide lors de la construction (mode 'Release')
- Lancez le test en cliquant sur l'exe ou en ligne de commande. Ne pas le lancer depuis le debuggeur (Visual C++).
- Fermez toutes les applications risquant de surveiller votre algo (anti-virus, firewall)


  • /


/* Initilisation du chrono */
/* La fonction QueryPerformanceCounter sera utilisée pour gagner en précision (nanoseconde).*/
#define TIMER_INIT() \
LARGE_INTEGER freq, start, stop; \
if (!QueryPerformanceFrequency(&freq)) \
	return -1;

/* Lancement du chrono */
#define TIMER_START() QueryPerformanceCounter(&start);

/* Arrêt du chrono et enregistrement du temps */
#define TIMER_STOP() \
QueryPerformanceCounter(&stop); \
if (_b==0) \
	timeSumList.push_back(stop.QuadPart - start.QuadPart); \
else \
	timeSumList[_algo++] += stop.QuadPart - start.QuadPart;

int main (int numArgs, char **args)
{
	/* Nombre de boucle de test - Plus ce nombre est élevé, plus le test sera long mais plus les rapports de temps seront précis */
	int numLoop = 10000;

	/* Tableau de temps d'exécution / timeSumList[0]='Temps cumulés de l'algo0' / timeSumList[1]='Temps cumulés de l'algo1' */
	vector<LONGLONG> timeSumList;

	TIMER_INIT();

	/* >>> Initialise les variables communes à tous les algos pour ne pas fausser les temps */
	vector<int> intList;
	for (int i=0; i<10000; ++i)
		intList.push_back(0);

	/* Lance les boucles de test */
	for (int _b=0; _b<numLoop; ++_b)
	{
		int _algo = 0;

		//*****************************************************************

		TIMER_START();

		{
			/* >>> ALGO 0 : Ecriture dans un vecteur en utilisant l'opérateur [] */
			int size = (int)intList.size();
			for (int i=0; i<size; ++i)
				intList[i] = 0;
		}

		TIMER_STOP();

		//*****************************************************************

		TIMER_START();

		{
			/* >>> ALGO 1 : Ecriture dans un vecteur en utilisant les fonctions membres begin() et end() */
			vector<int>::iterator iter;
			for (iter=intList.begin(); iter!=intList.end(); ++iter)


    				
  • iter = 0;

		}

		TIMER_STOP();

		//*****************************************************************

		TIMER_START();

		{
			/* >>> ALGO 2 : Ecriture dans un vecteur en utilisant les fonctions membres begin() et end() en initialisant les iterateurs */
			vector<int>::iterator iter;
			vector<int>::iterator iterBegin = intList.begin();
			vector<int>::iterator iterEnd = intList.end();
			for (iter=iterBegin; iter!=iterEnd; ++iter)


    				
  • iter = 0;

		}

		TIMER_STOP();
	}

	/* Le premier algo sert de temps de référence */
	LONGLONG elapsedRef = timeSumList[0];
	cout << "0 : 100%" << endl;

	/* Affiche l'écart de temps des autres algos en pourcentage (50% = 2x plus rapide / 100% = même vitesse / 200% = 2x plus lent) */
	int numTimes = (int)timeSumList.size();
	for (int _i=1; _i<numTimes; ++_i)
		cout << _i << " : " << (100*timeSumList[_i]/elapsedRef) << "%" << endl;

	getch();

	return 0;
}

A voir également

S'inscrire maintenant

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.

Du même auteur (cs_fuliculi)