Connaître le temps écoulé depuis le début d'une boucle

Version imprimable

Voir 40 message(s) de cette discussion en une page

27/07/2004, 13h32
rvweb

Connaître le temps écoulé depuis le début d'une boucle

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!
27/07/2004, 13h43
Emmanuel Delahaye

Re: Connaître le temps écoulé depuis le début d'une boucle

Citation:

Envoyé par rvweb

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>)
27/07/2004, 14h08
teska

Re: Connaître le temps écoulé depuis le début d'une boucle

Citation:

Envoyé par rvweb

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.
27/07/2004, 14h31
KORTA

utilises l'utilitaire gprof si c'est exclusivement du c.
Pour t'en servir et connaitre l'utilisation - man gprof -
27/07/2004, 15h55
Gandalf

Re: Connaître le temps écoulé depuis le début d'une boucle

Citation:

Envoyé par teska

Citation:

Envoyé par rvweb

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
27/07/2004, 15h56
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:

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).
27/07/2004, 15h59
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) ...
27/07/2004, 16h00
rvweb

Non, je suis sous Windows, mais clock() ne suffit pas?
27/07/2004, 16h09
Gandalf
Citation:
Envoyé par 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:

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:

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)
27/07/2004, 16h12
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é.
27/07/2004, 16h34
Gandalf

Citation:

Envoyé par 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é.

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...

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:

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:

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 ( :lol: je radote !!)

27/07/2004, 18h12
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!

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

Code:

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:

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.

Citation:

Envoyé par 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.
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:

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; }
Citation:
Envoyé par Dev-C++
Code:

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 . . .

27/07/2004, 20h38
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:

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

Citation:

Envoyé par 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...

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
27/07/2004, 22h37
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!
27/07/2004, 23h31
KORTA

Citation:

Envoyé par 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!

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.
28/07/2004, 12h50
fd

Yaboo :
pourquoi cette division par 1493556 ?

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

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:

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!

Voir 40 message(s) de cette discussion en une page