Discussion :

[siempre]

Bonjour,

Je voulais faire une expérimentation où je vais tracer une courbe (temps en fonction d'un nombre donné).
Pour mesurer le temps d'exécution d'un traitement alors j'ai mis ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
int main()
{
double debut,end;
..............
..............
debut = clock();
//traitements
..........
..........
 
 fin = clock();
 
fprintf(stderr, "\ntemps : %f\n", (double)(fin-debut) / (double) CLOCKS_PER_SEC);
 
    return 0;
}

Est ce que cette fonction est bonne ou bien il y a autres fonctions qui nous donnent le temps précis ni plus ni moins ? j'obtiens un temps t différent ou bien égale à chaque fois que je lance l'exécution de plus il arrive que
t =0.000000 malgré que il existe un traitement.
et comment éviter d'obtenir un temps nul ?


Merci.

[buse974]

Salut.
je suit tombée sur un FAQ qui pourait t'intéresser http://c.developpez.com/faq/?page=da...E_chronometrer.
et par curiosité je vais même esayer.

[buse974]

ben pour moi sa fonctionne sous linux avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
 
int main()
{
    clock_t start, end;
    double elapsed;
    unsigned int tim=0;
 
    start = clock();                                  /* Lancement de la mesure */
 
    while(tim<2546545454)                                        /* Faire quelque chose    */
    {
        tim++;
    }
    end = clock();                                    /* Arret de la mesure     */
 
    elapsed = ((double)end - start) / CLOCKS_PER_SEC; /* Conversion en seconde  */
 
    printf("%.2f secondes entre start et end.\n", elapsed);
 
    return 0;
}

6.16 secondes entre start et end.

[siempre]

Mon programme est en C et j'ai trouvé une solution en C++.
J'ai essayé de adapter le code c++ sur le lien suivant:
http://perso.numericable.fr/~fvirtma...imegettime.cpp

voici mon essai:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
 
#define MAX 100
 
int main()
{
	unsigned long t;
	int i;
 
	int tab[MAX];
 
	if (tab == NULL)
	{
		printf("echec allocation\n");
		return -1;
	}
 
	t = timeGetTime();
 
	for(i=0;i<MAX;i++)
		tab[i] = i;
 
	printf("temps de remplissage %ld millisecondes", timeGetTime()-t); 
 
	free(tab);
	system("pause");
	return 0;
}

La compilation ne passe pas bien:

1>------ Début de la génération : Projet : wakte, Configuration : Debug Win32 ------
1>Compilation en cours...
1>main.c
1>Édition des liens en cours...
1>main.obj : error LNK2019: symbole externe non résolu __imp__timeGetTime@0 référencé dans la fonction _main
1>c:\wakte\Debug\wakte.exe : fatal error LNK1120: 1 externes non résolus
1>Le journal de génération a été enregistré à l'emplacement "file://c:\wakte\wakte\Debug\BuildLog.htm"
1>wakte - 2 erreur(s), 0 avertissement(s)
========== Génération : 0 a réussi, 1 a échoué, 0 mis à jour, 0 a été ignoré ==========

est ce que la fonction "timeGetTime" n'est pas standard.

Je pense que la fonction "time" se passe bien de plus elle est utilisé par la plupart.

Merci.

[siempre]

Bonjour,

Voici le code que je trouve dans ce lien
http://msdn.microsoft.com/en-us/libr...69(VS.60).aspx

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
#include "time.h"
 
enum { ttuUnknown, ttuHiRes, ttuClock } TimerToUse = ttuUnknown;
LARGE_INTEGER PerfFreq;      // ticks per second
int PerfFreqAdjust; // in case Freq is too big
int OverheadTicks;   // overhead  in calling timer
 
void DunselFunction() { return; }
 
void DetermineTimer()
{
   void (*pFunc)() = DunselFunction;
 
   // Assume the worst
   TimerToUse = ttuClock;
   if ( QueryPerformanceFrequency(&PerfFreq) )
      {
      // We can use hires timer, determine overhead
      TimerToUse = ttuHiRes;
      OverheadTicks = 200;
      for ( int i=0; i < 20; i++ )
         {
         LARGE_INTEGER b,e;
         int Ticks;
         QueryPerformanceCounter(&b);
         (*pFunc)();
         QueryPerformanceCounter(&e);
         Ticks = e.LowPart - b.LowPart;
         if ( Ticks >= 0 && Ticks < OverheadTicks )
            OverheadTicks = Ticks;
         }
      // See if Freq fits in 32 bits; if not lose some precision
      PerfFreqAdjust = 0;
      int High32 = PerfFreq.HighPart;
      while ( High32 )
         {
         High32 >>= 1;
         PerfFreqAdjust++;
         }
      }
   return;
}
 
double DoBench(void(*funcp)())
{
   double time;      /* Elapsed time */
 
   // Let any other stuff happen before we start
   MSG msg;
   PeekMessage(&msg,NULL,NULL,NULL,PM_NOREMOVE);
   Sleep(0);
 
   if ( TimerToUse == ttuUnknown )
      DetermineTimer();
 
   if ( TimerToUse == ttuHiRes )
      {
      LARGE_INTEGER tStart, tStop;
      LARGE_INTEGER Freq = PerfFreq;
      int Oht = OverheadTicks;
      int ReduceMag = 0;
      SetThreadPriority(GetCurrentThread(), 
         THREAD_PRIORITY_TIME_CRITICAL);
      QueryPerformanceCounter(&tStart);
        (*funcp)();   //call the actual function being timed
      QueryPerformanceCounter(&tStop);
      SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
      // Results are 64 bits but we only do 32
      unsigned int High32 = tStop.HighPart - tStart.HighPart;
      while ( High32 )
         {
         High32 >>= 1;
         ReduceMag++;
         }
      if ( PerfFreqAdjust || ReduceMag )
         {
         if ( PerfFreqAdjust > ReduceMag )
            ReduceMag = PerfFreqAdjust;
         tStart.QuadPart = Int64ShrlMod32(tStart.QuadPart, ReduceMag);
         tStop.QuadPart = Int64ShrlMod32(tStop.QuadPart, ReduceMag);
         Freq.QuadPart = Int64ShrlMod32(Freq.QuadPart, ReduceMag);
         Oht >>= ReduceMag;
         }
 
      // Reduced numbers to 32 bits, now can do the math
      if ( Freq.LowPart == 0 )
         time = 0.0;
      else
         time = ((double)(tStop.LowPart - tStart.LowPart 
            - Oht))/Freq.LowPart;
      }
   else
      {
        long stime, etime;
      SetThreadPriority(GetCurrentThread(),
          THREAD_PRIORITY_TIME_CRITICAL);
      stime = clock();
      (*funcp)();
      etime = clock();
        SetThreadPriority(GetCurrentThread(), THREAD_PRIORITY_NORMAL);
      time = ((double)(etime - stime)) / CLOCKS_PER_SEC;
      }
 
  return (time);
}

dans ce code il y a les fonctions comme "QueryPerformanceCounter()", "clock()"...

Je ne sais pas comment je vais utiliser et appeler ce code dans mon programme C ?

Merci.

[buse974]

salut.
As tu regarder le liens sur la FAQ que je tes filer plus haut, car il y a un exemple sur linux et aussi sur windows.

Et de plus dans l'exemple QueryPerformanceCounter() et bien utiliser.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
#include <stdio.h>
#include <windows.h>
 
int main(void)
{
    LARGE_INTEGER start, end, freq;
    double elapsed;
 
    QueryPerformanceFrequency(&freq);
 
    QueryPerformanceCounter(&start);                                      /* Lancement de la mesure     */
 
    /* ... */                                                             /* Faire quelque chose        */
 
    QueryPerformanceCounter(&end);                                        /* Arret de la mesure         */
 
    elapsed = (1000.0 * (end.QuadPart - start.QuadPart)) / freq.QuadPart; /* Conversion en millsecondes */
 
    printf("%.0f millisecondes entre start et end.\n", elapsed);
 
    return 0;
}