AlexN
|
c'est une fonction qui m'a servi a evaluer le temps d'execution d'un programme avec different algos. Il y a des trucs qui ne te serviront à rien mais peut etre y a t il quelques idees a prendre.
#include
#include
#include
#include
/******************************************************************************/
/* Gestion d'un chronometre pour evaluer les performances du programme */
/******************************************************************************/
//#include "global.h"
//#include "chrono.h"
#include
#define VRAI (1)
#define FAUX (0)
typedef enum { TZERO, DEPINI, FININI, DEPMC, FINMC, DEPFS, FINFS, DEPTRI,
FINTRI, DEPAFF, FINAFF, DEPLIB, FINLIB, TZZ } StatutDuProgramme;
typedef
enum { METHODELEX = 1, METHODEPRJ, METHODELP, METHODEARB, METHODELA, METHODEPA,
METHODELAP, METHODENUL } Methode;
clock_t
TZero = 0,
TDepInitialisation = 0,
TFinInitialisation = 0,
TDepFichierMotsClefs = 0,
TFinFichierMotsClefs = 0,
TDepFichierSource = 0,
TFinFichierSource = 0,
TDepTri = 0,
TFinTri = 0,
TDepAffichage = 0,
TFinAffichage = 0,
TDepLiberation = 0,
TFinLiberation = 0;
void AfficherTempsFormate (clock_t n) {
if ( n < 1000 )
printf ("%d", n);
else {
AfficherTempsFormate (n / 1000);
printf (" %03d", n - 1000 * (n / 1000));
}
}
typedef enum { NANOSECONDE, PICOSECONDE, MICROSECONDE, MILLISECONDE, SECONDE,
HEURE, JOUR } DivTemps;
void ConvertirClockEnTemps (clock_t NbClocks, clock_t TTClocks) {
register clock_t Temps, Ecoule;
register int base =
(CLOCKS_PER_SEC >= 1000000) ? MICROSECONDE :
(CLOCKS_PER_SEC >= 1000) ? MILLISECONDE :
SECONDE;
register DejaEcrit = FAUX;
/* Convertir les NbClocks en secondes */
Ecoule = NbClocks;
Temps = NbClocks / CLOCKS_PER_SEC;
TTClocks /= CLOCKS_PER_SEC;
if ( Temps < 60*60*24 && TTClocks < 60*60*24) goto ConvertirHeure;
if ( Temps >= (60*60*24) ) {
printf ("%3d J ", Temps / (60*60*24) );
Ecoule -= ((Temps / (60*60*24)) * (60*60*24)) * CLOCKS_PER_SEC;
Temps -= (Temps / (60*60*24)) * (60*60*24);
DejaEcrit = VRAI;
} else printf (" ");
ConvertirHeure:
if ( Temps < 60*60 && TTClocks < 60*60 && !DejaEcrit ) goto ConvertirMinute;
if ( Temps >= (60*60) ) {
printf ("%2d h ", Temps / (60*60));
Ecoule -= ((Temps / (60*60)) * (60*60)) * CLOCKS_PER_SEC;
Temps -= (Temps / (60*60)) * (60*60);
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 h ");
else printf (" ");
ConvertirMinute:
if ( Temps < 60 && TTClocks < 60 && !DejaEcrit ) goto ConvertirSecondes;
if ( Temps >= 60 ) {
printf ("%2d min ", Temps / 60);
Ecoule -= ((Temps / 60) * 60) * CLOCKS_PER_SEC;
Temps -= (Temps / 60) * 60;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 min ");
else printf (" ");
ConvertirSecondes:
if ( Ecoule < CLOCKS_PER_SEC && TTClocks == 0 && !DejaEcrit ) goto ConvertirMillisecondes;
if ( Ecoule >= CLOCKS_PER_SEC ) {
printf ("%2d s ", Ecoule / CLOCKS_PER_SEC);
Ecoule -= (Ecoule / CLOCKS_PER_SEC) * CLOCKS_PER_SEC;
Temps -= Temps / CLOCKS_PER_SEC;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 s ");
else printf (" ");
ConvertirMillisecondes:
if (Temps != 0 && Ecoule == 0) return;
/* traiter les millisecondes */
if (base < SECONDE) {
if (Ecoule >= CLOCKS_PER_SEC/1000 && Ecoule != 0) {
printf ("%3d ms ", Ecoule / (CLOCKS_PER_SEC/1000));
Ecoule -= (Ecoule / (CLOCKS_PER_SEC/1000)) * (CLOCKS_PER_SEC/1000);
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 ms ");
else printf (" ");
}
/* traiter les microsecondes */
if (base < MILLISECONDE) {
if (Ecoule > CLOCKS_PER_SEC/1000 && Ecoule != 0) {
printf ("%3d mms ", Ecoule/1000);
Ecoule -= (Ecoule/1000) * 1000;
DejaEcrit = VRAI;
} else if ( DejaEcrit ) printf (" 0 mms ");
else printf (" ");
}
printf ("(");
if (NbClocks) {
AfficherTempsFormate(NbClocks);
printf (" clocks");
}
else
printf("hors capacite");
printf(")\n");
}
clock_t LireLeChrono (StatutDuProgramme NumStat) {
switch (NumStat) {
case TZERO : return TZero = clock(); break;
case DEPINI: return TDepInitialisation = clock(); break;
case FININI: return TFinInitialisation = clock(); break;
case DEPMC : return TDepFichierMotsClefs = clock(); break;
case FINMC : return TFinFichierMotsClefs = clock(); break;
case DEPFS : return TDepFichierSource = clock(); break;
case FINFS : return TFinFichierSource = clock(); break;
case DEPTRI: return TDepTri = clock(); break;
case FINTRI: return TFinTri = clock(); break;
case DEPAFF: return TDepAffichage = clock(); break;
case FINAFF: return TFinAffichage = clock(); break;
case DEPLIB: return TDepLiberation = clock(); break;
case FINLIB: return TFinLiberation = clock(); break;
default : break;
}
}
void AfficherLesResultatsDuChrono (int Methode) {
#define TT (TFinLiberation - TDepInitialisation)
printf ("\nTemps d'execution :\n");
switch (Methode) {
case METHODEPRJ: case METHODEARB:
printf ("Initialisation : ");
ConvertirClockEnTemps(TFinInitialisation - TDepInitialisation, TT);
printf ("Lecture des mots clefs : ");
ConvertirClockEnTemps(TFinFichierMotsClefs - TFinInitialisation, TT);
printf ("Tri : ");
ConvertirClockEnTemps(TFinTri - TFinFichierMotsClefs, TT);
printf ("Lecture du fichier source : ");
ConvertirClockEnTemps(TFinFichierSource - TFinTri, TT);
printf ("Affichage : ");
ConvertirClockEnTemps(TFinAffichage - TFinFichierSource, TT);
printf ("Liberation des ressources : ");
ConvertirClockEnTemps(TFinLiberation - TFinAffichage, TT);
break;
case METHODELEX:
printf ("Initialisation : ");
ConvertirClockEnTemps(TFinInitialisation - TDepInitialisation, TT);
printf ("Lecture du fichier source : ");
ConvertirClockEnTemps(TFinFichierSource - TFinInitialisation, TT);
printf ("Tri : ");
ConvertirClockEnTemps(TFinTri - TFinFichierSource, TT);
printf ("Affichage : ");
ConvertirClockEnTemps(TFinAffichage - TFinTri, TT);
printf ("Liberation des ressources : ");
ConvertirClockEnTemps(TFinLiberation - TFinAffichage, TT);
break;
}
printf ("TEMPS TOTAL POUR LA METHODE : ");
ConvertirClockEnTemps(TT, TT);
}
#undef TT
void AfficherLeTempsFinal (void) {
clock_t t;
printf ("\nTemps total d'execution : ");
ConvertirClockEnTemps(t = clock() - TZero, t);
}
/******************************************************************************/
/******************************************************************************/
/* main() : */
/* Fonction principale qui appelle tout le monde */
/******************************************************************************/
/******************************************************************************/
int main (int argc, char **argv) {
int i = 1; /* indice de l'argument suivant a lire */
register int err = EXIT_SUCCESS;
LireLeChrono(TZERO); /* Initialiser le chronometre */
for (i = 0; i < 1000000; i++); // Par exemple
AfficherLeTempsFinal(); /* Fin du chrono */
return err;
}
|