begin process at 2012 05 27 20:54:48
  Trouver un code source :
 
dans
 
Accueil > 

Code

 > 

API

 > TESTS DE RAPIDITÉ (SPRINTF, FOPEN...) [DEV-C++]

TESTS DE RAPIDITÉ (SPRINTF, FOPEN...) [DEV-C++]


 Information sur la source

Note :
6 / 10 - par 1 personne
6,00 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10
Catégorie :API Niveau :Débutant Date de création :12/10/2003 Vu / téléchargé :6 285 / 143

Auteur : Anacr0x

Ecrire un message privé
Commentaire sur cette source (7)
Ajouter un commentaire et/ou une note

 Description

Bon, ce prog ne sert pas a grand chose si ce n'est qu'a prouver que certaines fonctions sont a éviter (et que beaucoup utilisent quand même)

Pas mal de personnes sur ce site critique les fonctions genre sprintf, wsprintf, fopen, fwrite pour des raisons de performances, j'ai juste voulu vérifié !

Je vous préviens, j'ai fait ce code assez rapidemment, et il se peut que mes tests ne sont pas très exacts (bien que ca m'étonnerait)
Cependant, je dois avouer qu'ils m'ont assez étonner, je ne croyais pas tro au fait qu'une succession de strcat et otr était plus rapide qu'un sprintf, j'ai eu tord...
De plus, certains dise que les flux de fichier sont moins performant que le win32, moi j'ai trouver le contraire (bizarre...)

Si quelqu'un croit que je me trompe, qu'il n'hésite pas a le dire !

Source

  • #include <windows.h>
  • #include <time.h>
  • #include <stdio.h>
  • // Variables globales
  • char test[256];
  • int i;
  • clock_t avant, apres, duree1, duree2;
  • int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE PrevInstance, LPSTR CmdLine, int CmdShow)
  • {
  • /////////////////////////TEST 1 : vitesse de sprintf////////////////////////
  • /* sprintf sert à manipuler les chaines de caractères très facilement, mais
  • elle est réputer pour être extremement lente !!
  • Dans ce test, je place 1000000 fois une phrase (la même a chaque fois) dans
  • un buffer avec sprintf puis avec strcpy, strcat et autres */
  • // Variables utilisés
  • int test2=666666;
  • char *test3="blablablabla";
  • // méthode 1 : avec sprintf
  • avant = clock();
  • for(i=0; i<1000000; i++)
  • sprintf(test, "%s blablablabla %d blablablabla !!", test3, test2); // Une seul ligne suffit...
  • apres = clock();
  • duree1 = apres-avant;
  • sprintf(test, "Méthode 1 (avec sprintf) : %d", duree1);
  • MessageBox(NULL, test, "Vitesse de sprintf", MB_ICONERROR | MB_OK);
  • // méthode 2 : sans sprintf
  • avant = clock();
  • for(i=0; i<1000000; i++)
  • {
  • /* Pour arriver au même résultat, c'est quand même moins pratique !
  • De plus, on peut sans doute encore l'optimiser en se servant de
  • pointeur, mé la, g la flème... */
  • strcpy(test, test3);
  • strcat(test, " blablablabla ");
  • char test4[16]; _ultoa(test2, test4, 10);
  • strcat(test, test4);
  • strcat(test, " blablablabla !!");
  • }
  • apres = clock();
  • duree2 = apres-avant;
  • if(duree1>duree2) sprintf(test, "Méthode 2 (sans sprintf) : %d\n\nRESULTATS : méthode 2 est environ %d fois plus rapide !", duree2, duree1/duree2);
  • else sprintf(test, "Méthode 2 (sans sprintf) : %d\n\nRESULTATS : méthode 1 est environ %d fois plus rapide !", duree2, duree2/duree1);
  • MessageBox(NULL, test, "Vitesse de sprintf", MB_ICONERROR | MB_OK);
  • ////////////////////////////////////////////////////////////////////////////
  • //
  • // RESULTATS : la méthode sans sprintf est 3 fois plus rapide chez moi
  • //
  • // /!\ cependant, en faisant le test avec wsprintf, on remarque que cette
  • // fonction est tt de même plus rapide que sprintf
  • //
  • ////////////////////////////////////////////////////////////////////////////
  • /////////////////////////TEST 2 : flux ou win32 ????////////////////////////
  • /* fopen comme CreateFile servent à manipuler un fichier du disque dur et à
  • écrire dedans avec fwrite ou WriteFile.
  • fopen est réputer comme plus lent (de plus il fait appelle a une dll genre
  • msvcrt.dll ou un truc ds le genre)
  • Dans ce test, j'ouvre un fichier en écriture et j'écris 1000000 fois la
  • même phrase. Ensuite, je ferme et efface le fichier.*/
  • // méthode 1 : avec flux (fopen, fwrite, fclose)
  • avant = clock();
  • FILE *ouvre;
  • ouvre = fopen("c:\\test.txt", "w");
  • for(i=0; i<1000000; i++)
  • fwrite("bla", strlen("bla"), 1, ouvre);
  • if(ouvre!=NULL) fclose(ouvre);
  • apres = clock();
  • duree1 = apres-avant;
  • sprintf(test, "Méthode 1 (avec fopen) : %d", duree1);
  • MessageBox(NULL, test, "Flux ou Win32 ?", MB_ICONERROR | MB_OK);
  • DeleteFile("c:\\test.txt");
  • // méthode 2 : en win32 (CreateFile, WriteFile, CloseHandle)
  • avant = clock();
  • HANDLE hdl;
  • hdl=CreateFile("c:\\test.txt",GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
  • DWORD dw;
  • for(i=0; i<1000000; i++)
  • WriteFile(hdl, "bla", strlen("bla"), &dw, 0 );
  • CloseHandle(hdl);
  • apres = clock();
  • duree2 = apres-avant;
  • if(duree1>duree2) sprintf(test, "Méthode 2 (avec CreateFile) : %d\n\nRESULTATS : méthode 2 est environ %d fois plus rapide !", duree2, duree1/duree2);
  • else sprintf(test, "Méthode 2 (avec CreateFile) : %d\n\nRESULTATS : méthode 1 est environ %d fois plus rapide !", duree2, duree2/duree1);
  • MessageBox(NULL, test, "Flux ou Win32 ?", MB_ICONERROR | MB_OK);
  • DeleteFile("c:\\test.txt");
  • ////////////////////////////////////////////////////////////////////////////
  • //
  • // RESULTATS : la méthode avec flux est 4 a 6 fois plus rapide chez moi,
  • // contrairement à ce que je pensais au début...
  • //
  • ////////////////////////////////////////////////////////////////////////////
  • return 0;
  • }
#include <windows.h>
#include <time.h>
#include <stdio.h>

// Variables globales
char test[256];
int i;
clock_t avant, apres, duree1, duree2;

int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE PrevInstance, LPSTR CmdLine, int CmdShow)
{    
	/////////////////////////TEST 1 : vitesse de sprintf////////////////////////
	/* sprintf sert à manipuler les chaines de caractères très facilement, mais
	elle est réputer pour être extremement lente !! 
	Dans ce test, je place 1000000 fois une phrase (la même a chaque fois) dans 
	un buffer avec sprintf puis avec strcpy, strcat et autres */

	// Variables utilisés	
	int test2=666666;
	char *test3="blablablabla";

	// méthode 1 : avec sprintf
	avant = clock();
	for(i=0; i<1000000; i++)
		sprintf(test, "%s blablablabla %d blablablabla !!", test3, test2); // Une seul ligne suffit...

	apres = clock();
	duree1 = apres-avant;
	sprintf(test, "Méthode 1 (avec sprintf) : %d", duree1);
	MessageBox(NULL, test, "Vitesse de sprintf", MB_ICONERROR | MB_OK);

	// méthode 2 : sans sprintf
	avant = clock();
	for(i=0; i<1000000; i++)
	{
		/* Pour arriver au même résultat, c'est quand même moins pratique !
		De plus, on peut sans doute encore l'optimiser en se servant de 
		pointeur, mé la, g la flème... */

		strcpy(test, test3);
		strcat(test, " blablablabla ");
		char test4[16]; _ultoa(test2, test4, 10);
		strcat(test, test4);
		strcat(test, " blablablabla !!");
	}
	apres = clock();
	duree2 = apres-avant;
	if(duree1>duree2) sprintf(test, "Méthode 2 (sans sprintf) : %d\n\nRESULTATS : méthode 2 est environ %d fois plus rapide !", duree2, duree1/duree2);
	else sprintf(test, "Méthode 2 (sans sprintf) : %d\n\nRESULTATS : méthode 1 est environ %d fois plus rapide !", duree2, duree2/duree1); 
	MessageBox(NULL, test, "Vitesse de sprintf", MB_ICONERROR | MB_OK);
	////////////////////////////////////////////////////////////////////////////
	//
	// RESULTATS : la méthode sans sprintf est 3 fois plus rapide chez moi
	//
	// /!\ cependant, en faisant le test avec wsprintf, on remarque que cette
	// fonction est tt de même plus rapide que sprintf
	//
	//////////////////////////////////////////////////////////////////////////// 




	/////////////////////////TEST 2 : flux ou win32 ????////////////////////////
	/* fopen comme CreateFile servent à manipuler un fichier du disque dur et à
	écrire dedans avec fwrite ou WriteFile.
	fopen est réputer comme plus lent (de plus il fait appelle a une dll genre 
	msvcrt.dll ou un truc ds le genre) 
	Dans ce test, j'ouvre un fichier en écriture et j'écris 1000000 fois la 
	même phrase. Ensuite, je ferme et efface le fichier.*/

	// méthode 1 : avec flux (fopen, fwrite, fclose)
	avant = clock();
	FILE *ouvre;
	ouvre = fopen("c:\\test.txt", "w");
	for(i=0; i<1000000; i++)		
		fwrite("bla", strlen("bla"), 1, ouvre); 

	if(ouvre!=NULL) fclose(ouvre);
	apres = clock();
	duree1 = apres-avant;
	sprintf(test, "Méthode 1 (avec fopen) : %d", duree1);
	MessageBox(NULL, test, "Flux ou Win32 ?", MB_ICONERROR | MB_OK);
	DeleteFile("c:\\test.txt");

	// méthode 2 : en win32 (CreateFile, WriteFile, CloseHandle)
	avant = clock();
	HANDLE hdl;
	hdl=CreateFile("c:\\test.txt",GENERIC_WRITE,0,0,CREATE_ALWAYS,FILE_ATTRIBUTE_NORMAL,0);
	DWORD dw;
	for(i=0; i<1000000; i++)				
		WriteFile(hdl, "bla", strlen("bla"), &dw, 0 );	  

	CloseHandle(hdl);
	apres = clock();
	duree2 = apres-avant;
	if(duree1>duree2) sprintf(test, "Méthode 2 (avec CreateFile) : %d\n\nRESULTATS : méthode 2 est environ %d fois plus rapide !", duree2, duree1/duree2);
	else sprintf(test, "Méthode 2 (avec CreateFile) : %d\n\nRESULTATS : méthode 1 est environ %d fois plus rapide !", duree2, duree2/duree1);
	MessageBox(NULL, test, "Flux ou Win32 ?", MB_ICONERROR | MB_OK);
	DeleteFile("c:\\test.txt");
	////////////////////////////////////////////////////////////////////////////
	//
	// RESULTATS : la méthode avec flux est 4 a 6 fois plus rapide chez moi,
	// contrairement à ce que je pensais au début...
	//
	////////////////////////////////////////////////////////////////////////////

	return 0;
}

 Conclusion

En définitive, éviter les sprintf et choisissez plutot la méthode 2 (ou au pire wsprintf qui semble un peu plus rapide), surtt dans une boucle !!
Pareil pour l'écriture de fichier, utilisé de préférence fopen et co qui semble bien plus rapide pour l'écriture de gros fichier ! (cependant, je préfère avoir l'avis d'autres personnes la dessus avant d'en être certains)

 Fichier Zip

Les Membres Club peuvent télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !
  • Tests.cppTélécharger ce fichier [Réservé aux membres club]Voir ce fichier4 168 octets
  • Tests.exeTélécharger ce fichier [Réservé aux membres club]8 704 octets

Télécharger le zip


 Sources du même auteur

Source avec Zip Source avec une capture SCYTHIA V0.9.3
Source avec Zip Source avec une capture KILM V1.0 AVEC QT (WIN32, LINUX)
Source avec Zip Source avec une capture I FOUND U V1.3 (UN MESSENGER WIN32) [VS2003]
Source avec Zip Source avec une capture I FOUND U 1.1 (UN MESSENGER WIN32) [DEV-C++, VC++]
Source avec Zip NETSEND ANONYME V1.4B WIN32 (SANS MFC)

 Sources de la même categorie

Source avec Zip WIN32 TLS LENT par dguilmain
Source avec Zip VIDER ELEMENTS DE CORBEILLE WINDOWS7 (WIN64) par BruNews
Source avec Zip Source avec une capture FIND TEXT (WIN64) par BruNews
Source avec Zip DELETE DIRECTORY (WIN64) par BruNews
Source avec Zip ENUM DIRECTORY (WIN64) par BruNews

Commentaires et avis

Commentaire de BruNews le 12/10/2003 23:46:33 administrateur CS

Tu es certain que la boucle
for(i=0; i&lt;1000000; i++)  WriteFile(hdl, "bla", strlen("bla"), &dw, 0);
est reellement effectuee ?
Je pense refaire l'ensemble des que possible.
ciao...

Commentaire de Anacr0x le 13/10/2003 12:29:15

Oui, cette boucle est effectué, pour preuve, j'ai vérifié le fichier avant qu'il le suprime et il contien bien tt le text

Commentaire de BruNews le 13/10/2003 12:40:56 administrateur CS

oui je sais maintenant j'ai regarde aussi. Je le refais en mode graphique pour qu'on puisse relancer les tests plusieurs fois de suite.
Je le poste quand fini.

Commentaire de Anacr0x le 13/10/2003 12:49:57

oki, pas de pb, jsui curieux de voir si les résultats seront différents !

Commentaire de BruNews le 13/10/2003 14:06:03 administrateur CS

C'est fait.

Commentaire de Anacr0x le 13/10/2003 22:40:41

Bon ben BruNews a démontré que m'ont deuxième test est totalement faux, allez plutot voir sa source pour la comparaison flux/win32

Commentaire de Muff le 20/10/2003 11:22:36

Il faut faire gaffe sur les processeurs récents avec la mémoire cache
Ici, il doit placer les chaines de caractères en cache car il est dans une boucle et qu'il en a besoin tout le temps.
Ce qui fait que les deux boucles sont beaucoup plus rapides.
En application normale, ce n'est pas forcément le cas et les 2 méthodes seront surement moins rapides.
Je ne crois pas que cela modifie les résultats des tests puisque les deux en profitent mais bon...

 Ajouter un commentaire




Nos sponsors


Sondage...

CalendriCode

Mai 2012
LMMJVSD
 123456
78910111213
14151617181920
21222324252627
28293031   

Consulter la suite du CalendriCode

A découvrir



 
Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils.
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés

Google Coop CodeS-SourceS Google Coop CodeS-SourceS
Temps d'éxécution de la page : 0,421 sec (4)

Nous contacter | Annoncer sur CodeS-SourceS | Mentions légales