Discussion :

[Aspic]

Bonjour,

J'ai trouvé sur le net une classe qui gère un chronomètre qu imarchent parfaitement sous WIndows mais sous Linux c'est beaucoup plus lent... On dirait que le chronomètre n'est pas géré pareil.

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
#include "timerClass.h"
 
 
     ///////////////////////////////////////////////////////////////////////
    //   timerClass.cpp   //				David Foricher  -  03/05/04  //
   ///////////////////////////////////////////////////////////////////////
  //   The Timer class provides you an way to determine the exectution //
 // time of a program or one of its functions. (precision : 10ms)	  //
///////////////////////////////////////////////////////////////////////
 
 
Timer::Timer():startClockPeriodsM(0),endClockPeriodsM(0),startedM(false){}
 
 
Timer::Timer(const Timer &t):startClockPeriodsM(t.startClockPeriods()), endClockPeriodsM(t.endClockPeriods()), startedM(false){}
 
 
Timer::~Timer(){}
 
 
void Timer::start()
{
	// Record the number of clock ticks since the beginning of the execution
	startClockPeriodsM=clock();
	startedM=true;
}
 
 
void Timer::stop()
{
	endClockPeriodsM=clock();
	startedM=false;
}
 
void Timer::reset()
{
	startClockPeriodsM = 0;
	endClockPeriodsM=0;
	startedM=false;
}
 
 
void Timer::resume()
{
	if(startClockPeriodsM==0) start();
	else startedM=true;
}
 
 
bool Timer::started() const{ return startedM; }
 
 
clock_t Timer::startClockPeriods() const{ return startClockPeriodsM; }
 
 
clock_t Timer::endClockPeriods() const{ return endClockPeriodsM; }
 
 
double Timer::getTime(){
	// CLK_TCK is a constant that is equal to the number of clock ticks per second.
	// To have the result in ms, it is just divided by 1000
 
	if(started())
        return (clock()/((long) CLOCKS_PER_SEC/1000)-startClockPeriods()/((long) CLOCKS_PER_SEC/1000));
	else
	{
     	//printf("%d | %d\n", endClockPeriodsM, startClockPeriodsM);
        return (endClockPeriodsM/((long) CLOCKS_PER_SEC/1000)-startClockPeriodsM/((long) CLOCKS_PER_SEC/1000));
	}
}
 
 
bool Timer::operator == (Timer& t) {
	return (getTime()==t.getTime());
}
 
bool Timer::operator != (Timer& t) { return !((*this)==t); }
 
bool Timer::operator <= (Timer& t) { return getTime()<=t.getTime(); }
 
bool Timer::operator >= (Timer& t) { return getTime()>=t.getTime(); }
 
bool Timer::operator < (Timer & t) { return !((*this)>=t); }
 
bool Timer::operator > (Timer& t) { return !((*this)<=t); }
 
Timer& Timer::operator = (const Timer& t)
{
	startClockPeriodsM=t.startClockPeriods();
	endClockPeriodsM=t.endClockPeriods();
	return (*this);
}

Peut être qu'il y a des fonctions à ne pas utiliser sous Linux
...
A mon avis le problème vient de cette fonction :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
double Timer::getTime(){
	// CLK_TCK is a constant that is equal to the number of clock ticks per second.
	// To have the result in ms, it is just divided by 1000
 
	if(started())
        return (clock()/((long) CLOCKS_PER_SEC/1000)-startClockPeriods()/((long) CLOCKS_PER_SEC/1000));
	else
	{
     	//printf("%d | %d\n", endClockPeriodsM, startClockPeriodsM);
        return (endClockPeriodsM/((long) CLOCKS_PER_SEC/1000)-startClockPeriodsM/((long) CLOCKS_PER_SEC/1000));
	}
}

Merci

[Davidbrcz]

boost::timer c'est bien aussi.

Et rajouter des parenthèses dans les divisions ne coute rien. Et pas besoin de caster CLOCKS_PER_SEC en long.

Enfin, la prochaine fois, poste un code minimal complet: cad la déclaration de la classe aussi et un main car en l'état actuel pas moyen de tester !

[Aspic]

Désolé ce n'est pas mon code...
Voilà le .h :

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
 
#ifndef TIMER_CLASS
#define TIMER_CLASS
 
     ///////////////////////////////////////////////////////////////////////
    //   timerClass.h   //					David Foricher  -  03/05/04  //
   ///////////////////////////////////////////////////////////////////////
  //   The Timer class provides you an way to determine the exectution //
 // time of a program or one of its functions. (precision : 10ms)	  //
///////////////////////////////////////////////////////////////////////
 
 
#include <stdio.h>
#include <time.h>
 
class Timer{
 
public:
	Timer();
	Timer(const Timer &t);
	~Timer();
 
	void start();
	void stop();
	void reset();
	void resume();
	bool started() const;
	double getTime();
	clock_t startClockPeriods() const;
	clock_t endClockPeriods() const;
 
	bool operator == (Timer& t);
	bool operator != (Timer& t);
	bool operator < (Timer& t);
	bool operator > (Timer& t);
	bool operator <= (Timer& t);
	bool operator >= (Timer& t);
	Timer& operator = (const Timer& t);
 
private:
	clock_t startClockPeriodsM;
	clock_t endClockPeriodsM;
	bool startedM;
 
};
 
 
/*============================================================*\
 
start
-----
- Start the timer.
- If there was one, the last beginning time is overwritten.
 
 
stop
----
- Stop the timer.
 
 
resume
------
- Resume the timing after a stop().
- If the timer has never been started, it acts like start().
 
 
started
-------
- Return true if the timer is on.
 
 
getTime
-------
- Return the time elapsed between the start() and the stop().
- If the timer isn't stoped, return the time elapsed between the
  start() and the getTime().
 
\*============================================================*/
 
#endif

Le main est très simple :

Code :

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

1
2
3
4
 
Timer* chrono = new Timer();
chrono->start();
cout << chrono->getTime() << endl;

Sinon je n'utilise pas la librairie boost dans mon projet

PS ! Y'a déjà des parenthèses dans les divisions...

[Aspic]

J'ai fait pas mal de tests, on dirait que la constante CLOCKS_PER_SEC ne se comporte pas pareil sous Windows que sous Linux... Peut être un rapport avec 32 et 64 bits ?

[LittleWhite]

Bonjour,

Peut être faudrait-il utiliser les Timers d'Allegro ? (Le projet d'Aspic utilise Allegro)
Après, vous pourriez utiliser une variables constantes pour l'opération 'CLOCK_PER_SEC/1000' afin de simplifier le code. Du genre:

Code :

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

1
2
 
const unsigned int CLOCK_PER_MS = CLOCK_PER_SEC/1000;

D'après la page de documentation de clock sous Linux, il se peut que cela retourne -1 en cas d'erreur. Peut être que vous entrez dans ce cas ...
De plus, sous un système 32 bits ... il y aura un bug après 72minutes (limite du compteur)

De plus, c'est une constante qui est dépendante du CPU (bah oui ... tout les CPU ne font pas le même nombre de ticks par seconde)

[Aspic]

Je préfère éviter d'utiliser trop de timer d'Allegro, j'en utilise déjà 4 dans le projet, je suis limité à 17 Timers je crois mais il faut savoir que le Timers prennent beaucoup de ressources, donc moins on en utilise mieux c'est

Ensuite, oui j'ai lu aussi la doc et j'avais remarqué que ca pouvait retourner -1 mais ce n'est pas le cas chez moi.
Pour le bug des 72 minutes, j'ai vu aussi mais heureusement ca n'arrivera jamais

Enfin, avec plein de cout partout, j'ai remarqué que la constante CLOCKS_PER_SEC valait 1000 sur mon PC Windows 7 64 bits et sur mon Ubuntu emulé, elle vaut 1 000 000

Voilà, si y'a un moyen plus portable de faire un chronomètre sans timers d'Allegro je suis preneur.