Discussion :

[ero-sennin]

Bonsoir,

Je cherche à faire une Classe Chrono afin de pouvoir l'utiliser de façon simple dans mon programme. Ce que je souhaite faire, c'est utiliser des méthodes statiques afin de ne pas avoir à instancier d'objet.

J'ai ce code :

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
unit Chrono;
 
interface
 
uses Windows;
 
type TChrono=class
    private
      FFrequency    : Int64    ;    // Fréquence du compteur hautes performances.
      FStart, FStop : Int64    ;    // Valeurs du compteur au début et à la fin du chrono.
    public
      class Procedure Start;
      class Function Stop:Extended;
end;
 
 
implementation
 
class procedure TChrono.Start;
begin
  QueryPerformanceFrequency(FFrequency);
  QueryPerformanceCounter(FStart) ;
end;
 
class function TChrono.Stop:Extended;
begin
  Result:=(FStop-FStart)/FFrequency;
end;
 
end.

Et j'ai ces messages d'erreurs :

[Erreur] TChrono.pas(22): Variable instance 'FFrequency' inaccessible ici
[Erreur] TChrono.pas(23): Variable instance 'FStart' inaccessible ici
[Erreur] TChrono.pas(27): Variable instance 'FStop' inaccessible ici
[Erreur] TChrono.pas(27): Variable instance 'FFrequency' inaccessible ici

Est-ce possible de faire ce que je veux ? On utiliserai ainsi mon Chrono de cette façon :

Code :

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

1
2
3
4
5
6
7
8
procedure TForm1.Button1Click(Sender: TObject);
var
Temps:Extended;
begin
  TChrono.Start;
  //Traitement
  Temps:=TChrono.Stop;
end;

Merci d'avance
Cordialement

[TicTacToe]

Ceci est normal, les variables sont accessibles seulement si la classe est instanciée.

sinon pour déclarer des variables de classes
ca dépends de la version de Delphi.
J'ai pas encore essayé mais (je dis peut être une anerie) il me semble que dans la derniere version on peut définir des variables de classe.

Sinon, tu peux toujours ruser en définissant une variables globale à l'unité déclarée dans l'implémentation et y accéder par des méthodes de classes de ta classe
(je crois d'ailleurs que l'astuce est énoncée dans la FAQ )

edit: confirmé ici

[ero-sennin]

Salut TicTacToe,

Je viens de lire le post de la FAQ et c'est vrai que celà fonctionne. Néanmoins, il me faudra faire attention de ne pas utiliser les variables globales de la classe TChrono dans mon programme principal, parce que là j'y accède ...

Dommage que l'on ne puisse pas déclarer les variables dans la section private de la classe. Ca aurait arrangé certaines choses...

Merci

[ShaiLeTroll]

Normalement, comme ceci, tu ne peux pas accéder aux variable en dehors de l'unité, surtout qu'une seule valeur n'a besoin d'être partagée

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
unit Chrono;
 
interface
 
uses Windows;
 
type TChrono=class
  public
    class Procedure Start;
    class Function Stop: Extended;
end;
 
 
implementation
 
var
  _ChronoStart: Int64;    // Valeurs du compteur au début du chrono.
 
class procedure TChrono.Start;
begin
  QueryPerformanceCounter(_ChronoStart) ;
end;
 
class function TChrono.Stop: Extended;
var
  Frequency, Stop: Int64;
begin
  QueryPerformanceFrequency(Frequency);
  QueryPerformanceCounter(Stop) ;
 
   Result:= (Stop - _ChronoStart) / Frequency;
end;
 
end.

Sinon, tu peux aussi faire quelque chose de plus simple

appel

Code :

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

1
2
3
4
5
6
7
var
  StartTime: Int64;
begin
  GetBeginTime(StartTime);
  // Traitement
  ShowMessage(FormatMS(ElapsedTime(StartTime)));
end;

implementation

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
function FormatMS(MilliSecondes: Cardinal): string;
var
  Hour, Min, Sec: Cardinal;
begin
  Hour := MilliSecondes div 3600000; MilliSecondes := MilliSecondes mod 3600000;
  Min := MilliSecondes div 60000; MilliSecondes := MilliSecondes mod 60000;
  Sec := MilliSecondes div 1000; MilliSecondes := MilliSecondes mod 1000;
  Result := Format('%.2d:%.2d:%.2d:%.3d', [Hour, Min, Sec, MilliSecondes]);
end;
 
procedure GetBeginTime(var Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;
 
function ElapsedTime(var BeginTime: Int64): Cardinal;
var
  EndTime, TickPerSec: Int64;
begin
  QueryPerformanceCounter(EndTime);
  QueryPerformanceFrequency(TickPerSec);
  Result := Round((EndTime - BeginTime) / TickPerSec * 1000);
end;

[ero-sennin]

Salut ShaiLeTroll,

Merci pour ce code, je vais le regarder dans le courant de l'après midi .

Sinon, j'ai quelques questions :

Normalement, comme ceci, tu ne peux pas accéder aux variable en dehors de l'unité, surtout qu'une seule valeur n'a besoin d'être partagée

C'est parce que tu as défini la variable commençant par un tiret bas ?

Code :

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

1
2
3
4
implementation
 
var
  _ChronoStart: Int64;    // Valeurs du compteur au début du chrono.

Seconde question :

Code :

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

1
2
3
4
procedure GetBeginTime(var Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;

Je comprends pas trop le var dans le passage de paramètres. Ca a quelle(s) répercution(s) si on le met ou pas ? Comparé au code ci dessous, qu'est ce permet le tient avec le mot clé var :

Code :

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

1
2
3
4
procedure GetBeginTime(Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;

Dernière question, en ce qui concerne mon code. Là, je ne parle plus de méthode à portée de classe mais uniquement d'instanciation d'objet. Est ce que ce code est correct :

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
unit Chrono;
 
interface
 
uses Windows;
 
type TChrono=class
private
FFrequency    : Int64    ;    // Fréquence du compteur hautes performances.
FStart, FStop : Int64    ;    // Valeurs du compteur au début et à la fin du chrono.
    public
      constructor Start;
      function Stop:Extended;
end;
 
implementation
 
constructor TChrono.Start;
begin
  QueryPerformanceFrequency(FFrequency);
  QueryPerformanceCounter(FStart) ;
end;
 
function TChrono.Stop:Extended;
begin
  QueryPerformanceCounter(FStop) ;
  Result:=(FStop-FStart)/FFrequency;
  Self.Free;
end;
 
end.

Merci d'avance et désolé si mes questions paraissent un peu bêtes

[TicTacToe]

Salut TicTacToe,

Je viens de lire le post de la FAQ et c'est vrai que celà fonctionne. Néanmoins, il me faudra faire attention de ne pas utiliser les variables globales de la classe TChrono dans mon programme principal, parce que là j'y accède ...

Non, si ces variables globales sont déclarées dans la partie implémentation, seules des méthodes (de classes ou non) pourront accéder à ces var.
Ces variables sont "privées" à l'unité et donc non modifiables par les autres unités.

[Gilbert Geyer]

Bonjour,

Pour ma part j'ai laissé tomber l'utilisation du compteur hautes performances pour mes chronométrages depuis que j'ai appris que Windows piquait la main pour faire d'autres besognes quand cela lui chantait et le nombre de fois qu'il le voulait pendant les chronométrages et je me contente du code suivant où le chrono est encapsulé dans un object ce qui est suffisant :

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
 
type      oChrono = object TopDepart,Duree : longWord; // milliSecondes
                           procedure Top;
                           function  Mis(Format : byte) : string;
                           // Format=1 renvoie par ex 12h 15m 4s 45ms
                           // Format=2 renvoie        12:15:04:045
                           // Format=3 renvoie        44104045 ms
                    end;
 
procedure oChrono.Top;
begin     TopDepart:=GetTickCount; end;
 
function  oChrono.Mis(Format : byte) : String;
var       msp,he,mi,se,ms : longWord; s : string; t : shortString;
 
          function calibre(t : shortString; n : byte) : shortString;
          begin    while length(t)<n do t:='0'+t;
                   calibre:=t;
          end;
 
begin     Duree:= GetTickCount-TopDepart; // millisecondes passées
          //Duree:=12*60*60*1000 + 15*60*1000 + 4*1000 + 45; //12h 15m 4s 45ms
          msp:=Duree;
          ms:= msp mod 1000; msp:= msp div 1000;
          se:= msp mod 60;   msp:= msp div 60;
          mi:= msp mod 60;   msp:= msp div 60;
          he:= msp mod 60;   s:='';
          if Duree<=1000 then Format:=3;
          case format of
               1 : begin if he<>0 then s:=s+intToStr(he)+'h ';
                         if mi<>0 then s:=s+intToStr(mi)+'m ';
                         if se<>0 then s:=s+intToStr(se)+'s ';
                         s:=s+intToStr(ms)+'ms'; end;
               2 : begin t:=intToStr(he); s:=s+t+':'; //12:15:04:045
                         t:=intToStr(mi); t:=calibre(t,2); s:=s+t+':';
                         t:=intToStr(se); t:=calibre(t,2); s:=s+t+':';
                         t:=intToStr(ms); t:=calibre(t,3); s:=s+t; end;
               3 : s:=intToStr(Duree)+' ms';
          end;
          Mis:=s;
end;

... avant ceci pour essayer de conserver le compteur hautes hautes performances j'ai pensé qu'en fixant la priorité du chronométrage avec REALTIME_PRIORITY_CLASS cela empêcherait Windows de piquer la main pendant les chronométrages mais ça n'a servi à rien et depuis je me contente du GetTickCount.

A+

[ero-sennin]

Non, si ces variables globales sont déclarées dans la partie implémentation, seules des méthodes (de classes ou non) pourront accéder à ces var.
Ces variables sont "privées" à l'unité et donc non modifiables par les autres unités.

J'avais pas fait attention à ce détails! C'est désormais noté . Merci

Bonjour,
Pour ma part j'ai laissé tomber l'utilisation du compteur hautes performances pour mes chronométrages depuis que j'ai appris que Windows piquait la main pour faire d'autres besognes quand cela lui chantait et le nombre de fois qu'il le voulait pendant les chronométrages...

Ah, je ne savais pas celà ... Les écarts ne doivent pas être très important. Avec tout ces bouts de code sous la main, j'ai de quoi faire

Je ne regrette pas d'avoir posé ma question, j'en ai appris des choses!
Merci

[Gilbert Geyer]

Re-bonjour,

Ero-sennin a écrit :
Les écarts ne doivent pas être très important

... il m'est arrivé que les écarts varient du simple au double entre deux chronométrages successifs de processus courts ... ce qui exige pour les processus courts de refaire le test plusieurs fois pour éliminer les résultats où visiblement c'est d'autres besognes que j'ai chronométré par contre pour des processus qui durent 5 minutes les écarts relatifs ne perturbent pas trop mais mon poste n'est pas en réseau et est donc moins perturbé par des tâches qui s'exécutent en arrière plan. En plus je m'arrange toujours afin qu'un test ne dépasse pas les 5 minutes ... c'est déja long et en général quand on se lance dans des tests de vitesse on est parti pour en faire toute une série.

Par contre je pensais que quelqu'un allait apporter une réponse à comment donner la priorité immédiate au chronométrages et voiçi sur quoi je me suis basé sans succès pour mes essais :

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
Pour changer la priorité de l'application
ex : lancer Prio($80) pour la placer en priorité haute, et Prio($20) pour revenir à une priorité normale.
Cela "peut" accélérer certains processus 

procedure Prio(const PriorityClass : Cardinal); 
var hProcess, pid : Cardinal;
begin
  pid := GetCurrentProcessId();
  hProcess := OpenProcess($40, true, pid);
  SetPriorityClass(hProcess, PriorityClass);
  CloseHandle(hProcess);
end;

dwPriorityClass : valeurs

HIGH_PRIORITY_CLASS	: pour tâches à executer immediatement. : $80 = 128

IDLE_PRIORITY_CLASS : pour tâches à exécuter lorsque le système est désoeuvré. (sauvegarde d'écran par exemple ) :  $40 = 64

NORMAL_PRIORITY_CLASS : pour process sans besoin spécial : $20 = 32

REALTIME_PRIORITY_CLASS : pour process à executer avec la plus haute priorité possible y compris face à des opérations du système : $100   = 256

... donc si quelqu'un a une idée pour empêcher Windows de piquer la main ce serait intéressant de le savoir.

A+

[ShaiLeTroll]

Code :

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

1
2
3
4
procedure GetBeginTime(var Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;

Je comprends pas trop le var dans le passage de paramètres. Ca a quelle(s) répercution(s) si on le met ou pas ? Comparé au code ci dessous, qu'est ce permet le tient avec le mot clé var :

Code :

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

1
2
3
4
procedure GetBeginTime(Value: Int64);
begin
  QueryPerformanceCounter(Value);
end;

sans Var, Value est une copie de la variable appelante, la modifier n'a aucun implact
avec Var, Value est un pointeur sur la variable appelante, la modifier modifie la valeur dans le fonction appelante

F1 t'expliquera tout en détail (surtout le chapitre "Sémantique des paramètres")

Dernière question, en ce qui concerne mon code. Là, je ne parle plus de méthode à portée de classe mais uniquement d'instanciation d'objet. Est ce que ce code est correct :

Code :

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

1
2
3
4
5
6
function TChrono.Stop:Extended;
begin
  QueryPerformanceCounter(FStop) ;
  Result:=(FStop-FStart)/FFrequency;
  Self.Free;
end;

Correct, il l'est, il est juste peu fiable, pour une forme, il faudra utiliser Release, ... tu un risque de violation d'acces, si en théorie cela peut fonctionner, personne ne le fait ... mais tu peux oser ceci

Code :

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

1
2
3
4
5
6
7
destructor TChrono.Stop(out ResultChrono :Extended);
begin
  QueryPerformanceCounter(FStop) ;
  ResultChrono :=(FStop-FStart)/FFrequency;
 
  inherited Destroy();
end;

Bon, cela retire la protection du Free, sur l'objet nil, mais bon, c'est pas grave, moi je l'ai utilisé comme ceci, pour rendre mon code assez lisible et que la libération soient natutelle (Create\Free, Begin\End ...)

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
type
  TMaster = class(TObject)
  public
    class function BeginTask(TypeTask: TTaskType): TCustomTask;
  end;
 
  TCustomTask = class(TObject)
  public
    destructor EndTask();
  end;
 
  TCustomTaskClass = class of TCustomTask;
 
  TTaskHello = class(TCustomTask);
 
implemenation
 
const
  TASK : array[TTaskType] of TCustomTaskClass = (TTaskHello, TTaskGoodBye);
 
class function TMaster.BeginTask(TypeTask: TTaskType): TCustomTask;
begin
  Result := TASK[TypeTask].Create();
end;
 
//----------------------------------------------//
 
with TMaster.BeginTask(ttHello) do
try
  ...
finally
  EndTask(); 
end;

Il faut savoir que n'importe quelle API Windows permet à ce dernier, de prendre la main au programme en toute sécurité (contexte de pile, thread, ...) et pas spécialement avec le Compteur, sinon, avec GetTickCount, il est difficile d'avoir un temps plus précis que 10ms, d'ailleurs, si tu as fais des tests, tu as souvent pour un traitement court, des temps variant entre 0 ms, 15-16 ms ou 30-31 ms, puis passer ces temps, cela devient plus précis, c'est tout simple, qu'il a relaché la main aussi, ...

je rappelle que windows c'est multi-processus, on est pas sous DOS où cela bloque tout, un programme ne doit pas bloquer l'opération des autres programmes, d'ailleurs, même un programme qui occupe le processeur à 100% en faisiant ni sleep, ni waitmessage, ni d'appel à une API, genre le code qui suit, tu peux toujours utiliser tes autres applis, parce que windows ne se gène pas pour allouer du temps processeur aux autres processus ... et heureusement d'ailleurs, car comment faire un virus bien chiant et ultra simple, dès le démarrage de windows un programme qui bouffe tout le temps processeur, qui ne relache jamais la main, et donc rend impossible l'utilisation de l'ordinateur ... c'est ce qui arrivait avec Win98 qui était plus fragile à ce sujet, et pouvait bloquer plus facilement, parfois Win2K, mais les Pack on améliorer cela, imagine, tu as lancé ton programme, il tourne à fond mais il fait des conneries, tu veux le killer, tu es bien content que le système aie la main pour afficher le gestionnaire de processus (même avec difficulté car peu de temps processeur pour le faire)

Code :

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

1
2
For I := 0 to MaxInt do
  Inc(K);

Maintenant, avec les processeurs multi-core, c'est encore plus complexe, windows pouvant te changer de processeur selon les besoins ... et cela dépasse de loin mes connaissances

[ero-sennin]

sans Var, Value est une copie de la variable appelante, la modifier n'a aucun implact
avec Var, Value est un pointeur sur la variable appelante, la modifier modifie la valeur dans le fonction appelante

F1 t'expliquera tout en détail (surtout le chapitre "Sémantique des paramètres")

Oui, je viens de comprendre la chose, la variable est passé par adresse et non par valeur ce qui a pour effet de la modifier dans le corps de la procédure ou fonction.

Bon, cela retire la protection du Free, sur l'objet nil, mais bon, c'est pas grave, moi je l'ai utilisé comme ceci, pour rendre mon code assez lisible et que la libération soient natutelle (Create\Free, Begin\End ...)

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
type
  TMaster = class(TObject)
  public
    class function BeginTask(TypeTask: TTaskType): TCustomTask;
  end;
 
  TCustomTask = class(TObject)
  public
    destructor EndTask();
  end;
 
  TCustomTaskClass = class of TCustomTask;
 
  TTaskHello = class(TCustomTask);
 
implemenation
 
const
  TASK : array[TTaskType] of TCustomTaskClass = (TTaskHello, TTaskGoodBye);
 
class function TMaster.BeginTask(TypeTask: TTaskType): TCustomTask;
begin
  Result := TASK[TypeTask].Create();
end;
 
//----------------------------------------------//
 
with TMaster.BeginTask(ttHello) do
try
  ...
finally
  EndTask(); 
end;

En effet, à la lecture, on voit bien le Begin et End, ce qui est appréciable pour une question de maintenance. Je me vois bien pencher vers cette solution.

Avec GetTickCount, il est difficile d'avoir un temps plus précis que 10ms, d'ailleurs, si tu as fais des tests, tu as souvent pour un traitement court, des temps variant entre 0 ms, 15-16 ms ou 30-31 ms, puis passer ces temps, cela devient plus précis, c'est tout simple, qu'il a relaché la main aussi, ...

Oui, c'est d'ailleurs pour celà que je m'étais dirigé vers le compteur Haute Performance

Merci pour ces informations bien utiles ... et puis, j'ai pu voir à quoi servait VAR et aussi OUT.

A+