Discussion :

[rvweb]

Bonjour,

J'aimerais connaître le temps qui s'est écoulé entre le début de ma boucle principale et n'importe quel endroit de cette boucle.
Il faudrait de plus que ce temps soit précis car ma boucle est rapide (elle s'execute plusieurs fois par seconde).
Et enfin si le temps pouvait être en secondes ça serait parfait!

Voilà, merci d'avance pour votre aide!

[Emmanuel Delahaye]

J'aimerais connaître le temps qui s'est écoulé entre le début de ma boucle principale et n'importe quel endroit de cette boucle.
Il faudrait de plus que ce temps soit précis car ma boucle est rapide (elle s'execute plusieurs fois par seconde).
Et enfin si le temps pouvait être en secondes ça serait parfait!

C'est pas une FAQ?

clock() permet de mesurer le temps CPU en ticks. La conversion se fait à l'aide de CLOCKS_PER_SEC. (<time.h>)

[teska]

Il faudrait de plus que ce temps soit précis car ma boucle est rapide (elle s'execute plusieurs fois par seconde).
Et enfin si le temps pouvait être en secondes ça serait parfait!

Si ta boucle s'exécute plusieurs fois par seconde, tu ne préfererai pas un temps en milliecondes plutôt ? Car sinon tu auras 0 sec à chaque passage.

[KORTA]

utilises l'utilitaire gprof si c'est exclusivement du c.
Pour t'en servir et connaitre l'utilisation - man gprof -

[Gandalf]

Il faudrait de plus que ce temps soit précis car ma boucle est rapide (elle s'execute plusieurs fois par seconde).
Et enfin si le temps pouvait être en secondes ça serait parfait!

Si ta boucle s'exécute plusieurs fois par seconde, tu ne préfererai pas un temps en milliecondes plutôt ? Car sinon tu auras 0 sec à chaque passage.

Il existe un concept qui est la notion de virgule ainsi 1ms peu s'écrire : 0,001s et il faut avouer que ca complique un peu les calculs, mais c'est tres pratique

[rvweb]

J'utilise des vitesses en m/s dans mon programme, c'est pourquoi je voudrais des secondes. En fait j'aimerais obtenir quelque chose comme 0.001 s/boucle, la fonction clock() est-elle assez précise?
Est-ce que le code suivant fonctionne?

Code :

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

1
2
3
clock_t temps = clock();
// Boucle...
clock_t t=(clock()-temps)/CLOCKS_PER_SEC;

Chez moi ça n'a pas l'air (j'essaie de faire avancer un personnage mais cela ne marche pas).

[KORTA]

Si tu es sous linux tu as gettimeofday() qui est extra précis .
Et aussi, au risque de me répéter l'utilitaire gprof (super pratique) ...

[rvweb]

Non, je suis sous Windows, mais clock() ne suffit pas?

[Gandalf]

J'utilise des vitesses en m/s dans mon programme, c'est pourquoi je voudrais des secondes. En fait j'aimerais obtenir quelque chose comme 0.001 s/boucle, la fonction clock() est-elle assez précise?
Est-ce que le code suivant fonctionne?

Code :

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

1
2
3
clock_t temps = clock();
// Boucle...
clock_t t=(clock()-temps)/CLOCKS_PER_SEC;

Chez moi ça n'a pas l'air (j'essaie de faire avancer un personnage mais cela ne marche pas).

1/ clock_t est un entier en general donc tu obtiens 0 c'est normal

Code :

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

double duree = (double)(clock()-t)/(double)(CLOCKS_PER_SEC);

2/ ensuite regarde la resolution de clock() je ne suis pas sure que ce sois aussi fin que ce que tu veux... il faudra alors faire un moyenne sur plusieurs boucles (et ce sera plus representatif)

[rvweb]

Oui je crois que tu as raison, il me semble que la précision maximale est bien la seconde, donc à chaque boucle t=0.
Je vais essayer d'utiliser autre chose, comme gprof dont tu m'as parlé.

[Gandalf]

Oui je crois que tu as raison, il me semble que la précision maximale est bien la seconde, donc à chaque boucle t=0.
Je vais essayer d'utiliser autre chose, comme gprof dont tu m'as parlé.

C'est de l'ordre de grandeur du centieme de seconde...

donc apte a mesurer des durees d'au minimum un dizième de seconde, ou alors des moyennes...

[KORTA]

Voici une adresse ou tu peux trouver des informations http://www.rembrandtstr.bocholt.de/m.../libc_296.html.

Je cite le code cité en exemple que j'ai remanié afin d'affichier les résultats intermédiaires.

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
 
#include <time.h>
#include <stdio.h>
 
int
main(int argc,char** argv)
{
 
int i;
 
 
clock_t start, end;
double elapsed;
 
start = clock();
 
printf("START:%i\n",start);
for(i=0;i<1000;i++)
	{/*instructions*/}
 
end = clock();
printf("END:%i\n",end);
elapsed = ((double) (end - start)) / CLOCKS_PER_SEC;
printf("ELAPSED: %G\n",elapsed);
 
return 1;
}

Ce qui en compilant

Code :

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

1
2
3
4
5
6
7
8
9
 
E:\home>gcc test.c
 
E:\home>a.exe
START:0
END:0
ELAPSED: 0
 
E:\home>

Ce qui est évidemment pas le résultat attendu, j'ai l'impression que la fonction clock ne fonctionne tout simplement pas sous windows.
Si tu utilises mingw, utilises gprof ( je radote !!)

[rvweb]

Je ne suis pas sur d'avoir bien compris le principe de gprof. On peut l'utiliser dans un programme, ou alors c'est en quelque sorte un compte rendu qu'on étudie une fois le programme fermé? Si c'est le cas ce n'est pas ce qu'il me faut. Ce qu'il me faut, c'est quelque chose auquel on peut accéder à l'intérieur du programme. Si gprof le permet, pourrais-tu m'expliquer comment on s'en sert dans un programme? Je n'ai pas trouvé de pages où cela est expliqué très clairement...
Par ailleurs j'ai entendu parler de GetTickCount(), mais je ne sais pas comment l'utiliser et je ne suis pas sûr que cela soit compatible avec Dev-c++, que j'utilise (il me semble que cette fonction est propre à VC). Sinon existe-t-il d'autres méthodes?

En fait j'attend n'importe quelle proposition pourvu qu'elle fonctionne et qu'elle soit assez simple à utiliser (je débute encore), ou alors bien expliquée!

Voilà, merci d'avance pour votre aide!

[Yabo]

j'ai une solution non portable qui marche sous VC++. Je n'ai jamais testé sous dev-c++.

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
 
#include <stdlib.h>
#include <stdio.h>
 
namespace tsc
{
 
__int64 mt_i;
__int64* pmt_i = &mt_i;
 
__declspec(naked) void __stdcall
writeT()
{
   __asm
   {
 
      rdtsc
 
      mov      ecx,   pmt_i
 
      mov      [ecx],   eax
      mov      [ecx + 4], edx
 
      ret
 
   }
}
 
 
__declspec(naked) void __stdcall
diffT(double *t)
{
   __asm
   {
      rdtsc
 
      push   ebp
      mov      ebp,   esp
 
      mov      ecx,   pmt_i
 
      sub      eax,   [ecx]
      sbb      edx,   [ecx + 4]
      mov      [ecx],   eax
      mov      [ecx + 4], edx
   }
 
   *t = (double)mt_i / 1493556;
 
   __asm
   {
      pop      ebp
      ret
   }
}
 
}

Ca s'utilise comme ca :

Code :

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

1
2
3
4
5
 
double duree;
tsc::writeT();
// ce que tu veux
tsc::diffT(&duree); // duree contient le temps depuis l'appel a writeT();

Je n'ai aucune idée de si ca marche autre part que sous VC++, en tout cas c'est ultra précis.

[Emmanuel Delahaye]

Voici une adresse ou tu peux trouver des informations http://www.rembrandtstr.bocholt.de/m.../libc_296.html.

Je cite le code cité en exemple que j'ai remanié afin d'affichier les résultats intermédiaires.
j'ai l'impression que la fonction clock ne fonctionne tout simplement pas sous windows.

Elle fonctionne, simplement, il faut multiplier les tests pour avoir une mesure significative.

D'autre part, dans ton code, la boucle est vide. Selon les options d'optimisations en vigueur, elle pourrait très bien être ignorée par le compilateur.

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
#include <time.h>
#include <stdio.h>
 
int volatile data = 0;
 
static void test (void)
{
   int i;
   for(i = 0; i < 1000; i++)
   {
      if (data)
      {
         break;
      }
   }
}
 
int main()
{
   clock_t start, end;
   double elapsed;
 
   {
      unsigned long n;
      unsigned long const N = 1000000ul;
 
      start = clock();
      printf ("   START:%d\n", (int) start);
 
      for (n = 0; n < N; n++)
      {
         test ();
      }
 
      end = clock();
      printf("      END:%d\n",(int)end);
      elapsed = ((double)end - start) / CLOCKS_PER_SEC;
 
      printf("  ELAPSED: %f ms\n",1000 * elapsed);
      printf("UNIT TEST: %f ms\n",1000 * elapsed / N);
   }
 
   system("pause");
 
   return 0;
}

Code :

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

1
2
3
4
5
6
 
   START:0
      END:2580
  ELAPSED: 2580.000000 ms
UNIT TEST: 0.002580 ms
Appuyez sur une touche pour continuer . . .

[KORTA]

Autant pour moi pour l'info précedente sur clock(), je pensais que clock renvoyait le nombre de ticks depuis le démarrage de la machine ce qui n'est semble t'il pas le cas.... bref!
A titre indicatif et par curiosité, voici les chiffres que j'obtiens:

Code :

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

1
2
3
4
5
6
7
 
E:\home>a.exe
   START:0
      END:3843
  ELAPSED: 3843.000000 ms
UNIT TEST: 0.003843 ms
Appuyez sur une touche pour continuer...

Autrement

Je ne suis pas sur d'avoir bien compris le principe de gprof. On peut l'utiliser dans un programme, ou alors c'est en quelque sorte un compte rendu qu'on étudie une fois le programme fermé? Si c'est le cas ce n'est pas ce qu'il me faut. Ce qu'il me faut, c'est quelque chose auquel on peut accéder à l'intérieur du programme. Si gprof le permet, pourrais-tu m'expliquer comment on s'en sert dans un programme? Je n'ai pas trouvé de pages où cela est expliqué très clairement...

En fait gprof rend compte de la derniere execution de ton executable. Il permet de consulter le temps passé dans chaque fonction et le nombre d'appels effectués.
pour s'en servir il faut utiliser gcc , puis compiler avec l'option -pg,
Ensuite executer le programme executable
pui lancer gprof qui rend compte des temps pasés

[rvweb]

Donc gprof est bien une analyse a posteriori des temps d'execution de mon programme? Je ne peux donc pas l'utiliser dans mon programme pour calculer des temps?
Sinon j'ai essayé ton code avec clock(), mais si j'ai bien compris tu fais une moyenne sur de nombreux calculs. Or il faudrait que je sache le temps écoulé à chaque boucle (mais si je ne trouve pas de méthode je pourrai toujours faire une moyenne sur plusieurs boucles).
Quant à la fonction asm de Yabo, Dev-c++ n'a tout simplement pas voulu la compiler car trop d'erreurs de syntaxe. En fait je crois qu'il n'a pas reconnu que c'était de l'asm...
Là je vais chercher à utiliser QueryPerformanceCounter, si vous pouviez m'en dire plus...

En tout cas merci pour vos explications et vos codes!

[KORTA]

Donc gprof est bien une analyse a posteriori des temps d'execution de mon programme? Je ne peux donc pas l'utiliser dans mon programme pour calculer des temps?
Sinon j'ai essayé ton code avec clock(), mais si j'ai bien compris tu fais une moyenne sur de nombreux calculs. Or il faudrait que je sache le temps écoulé à chaque boucle (mais si je ne trouve pas de méthode je pourrai toujours faire une moyenne sur plusieurs boucles).
Quant à la fonction asm de Yabo, Dev-c++ n'a tout simplement pas voulu la compiler car trop d'erreurs de syntaxe. En fait je crois qu'il n'a pas reconnu que c'était de l'asm...
Là je vais chercher à utiliser QueryPerformanceCounter, si vous pouviez m'en dire plus...

En tout cas merci pour vos explications et vos codes!

Gprof t'indiquera le temps passé dans chaque fonction et l'arboresence des appels simplement.
Pour clock(), la méthode a l'air de fonctionner montre nous le code que tu désires utiliser si tu peux , pour qu'on essaye d'y trouver une solution.
Pour l'asm de devc++ (comme celle de mingw) c'est normal la syntaxe asm est particuliere et est différente de celle qu'on t'a postée précédemment.

[fd]

Yaboo :
pourquoi cette division par 1493556 ?

[rvweb]

Je ne vais pas donner tout mon code, car il y en a beaucoup, mais voici en gros ce que je voudrais faire:

Code :

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

1
2
3
4
5
6
7
8
9
while (1) { // Boucle principale dans la fonction main()
        float t=0; // Initialisation du temps de référence au début de la boucle
 
        coordonnees();
        affichage();
        perso_mouvements();
        camera_mouvements();
        evenements();
}

Puis dans une des fonctions de la boucle principale, perso_mouvements() en l'occurrence:

Code :

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

1
2
3
4
perso_mouvements() {
     float ecoule=clock()-t; // Calcul le temps écoulé entre la définition de t et l'execution de cette ligne
     // Utilisation de t pour calculer des nouvelles coordonnées du perso
}

Voilà, j'espère que c'est plus clair ainsi. Je n'ai pas donné un code que j'utilise mais une "idée" du genre de fonction que j'aimerais trouver, le problème étant je le rappelle que clock() ne donne que des secondes, alors que ecoule serait plutot en millisecondes.

Sinon si ce que je demande n'est pas réalisable, j'ai pensé faire quelques boucles "test" afin de voir combien de temps met une boucle à s'executer sur un ordinateur donné, puis utiliser cette valeur.
Et en dernier recours, je pourrai faire une moyenne sur plusieurs boucles, mais cela voudrait dire que les coordonnées de mon perso seraient actualisées toutes les secondes minimum. Pas terrible...

Voilà, j'espère avoir été assez clair! Et merci!