Discussion :

[Rayek]

Bonjour,

En prenant exemple sur le code de Paul Toth, je me suis dis qu'il serait pas mal de faire un code dans ce style en passant des fonctions en paramètres d'une autres afin qu'elle me retourne le temps mis pas celle ci.

Ci-dessous un début d'idée sur le fonctionnement que je voudrais réaliser.

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
 
TProcess : function : integer of Object;
 
TMainClass = Class(TObject)
  public
    // Diverses fonction du style function (Nombre de param variable) : Integer;
 
    function CalcTime(AProcessName : String;AProcess : TProcess; Logs : TStringList) : Integer;
end;
 
function TMainClass.CalcTime(AProcessName : String;AProcess : TProcess; Logs : TStringList) : Integer
var
var
  Begintime, endtime,TickPerSec : int64;
  iTmp : Int64;
 
begin
  QueryPerformanceCounter(BeginTime);
 
  Result := Process;
 
  QueryPerformanceCounter(EndTime);
  QueryPerformanceFrequency(TickPerSec);
  iTmp := Round((EndTime - BeginTime) / TickPerSec * 1000);
  Logs.Add(Format(AProcessName + ' %d',[iTmp]));
end;

Je pense que cela ne sera pas fonctionnel en l'état au vu que les fonctions n'ont pas un même nombre de paramètres.

Mes questions :

- Est ce réalisable ?
- Si oui, que manque-t-il à ce code ? Doit on écrire d'une autre manière ?

Merci

[Paul TOTH]

ça me parait bien, mais je connais un outils très pratique pour cela c'est SamplingProfiler.

ce programme laisse l'application tourner et vient régulièrement regarder ce qu'elle est en train de faire. Dès lors elle établi un rapport sur le temps passé dans chaque portion de code. Je trouve cela très instructif.

[Rayek]

ça me parait bien, mais je connais un outils très pratique pour cela c'est SamplingProfiler.

ce programme laisse l'application tourner et vient régulièrement regarder ce qu'elle est en train de faire. Dès lors elle établi un rapport sur le temps passé dans chaque portion de code. Je trouve cela très instructif.

Cela a l'air d'être pas mal comme outils mais j'ai besoin des informations dans mes Logs.

donc après test, cela ne fonctionne pas

Code Définition de la classe :

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

1
2
3
4
5
6
7
 
TCommandeClass = Class(TMainClass)
   private
     function SetData(ART_ID, SSF_ID : Integer) : Integer;
   public
    function DoMajTable(ADoMaj : Boolean) : Boolean;override;
end;

Code Procedure d'exécution de la classe :

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

1
2
3
4
5
6
7
8
9
10
11
12
 
function TCommandeClass.DoMajTable(ADoMaj : Boolean) : Boolean;
begin
  // Si je met
  CalcTime('SetData',SetData(ART_ID, SSF_ID : Integer),FerrLogs);
  // J'ai l'erreur type incompatible TProcess et Integer
 
  // Si je test
  CalcTime('SetData',TProcess(SetData(ART_ID, SSF_ID : Integer)),FerrLogs);
 // J'ai une violation d'accès.
 
end;

Surtout que tu risques de compter le temps de ta gestion du re-passage de paramètre (genre par pointeur sur la pile ou les trucs de SJRD dans SEPI)

Perso, je me suis fait 3 fonctions que j’utilise si j'ai ce besoin

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

J'utilise déjà quelques choses dans le style mais j'ai plus de 50 fonctions à encadrer et cela serait plus simple de passer par une procèdure/fonction où j'ai juste à passer en paramètre celle que je veux tester.

[ShaiLeTroll]

J'utilise déjà quelques choses dans le style mais j'ai plus de 50 fonctions à encadrer et cela serait plus simple de passer par une procèdure/fonction où j'ai juste à passer en paramètre celle que je veux tester.

Le chronometrage, tu veux le conserver par la suite ?
Effectivement, je ne fais cela que lorsque je constate une lenteur, c'est un code jetable le temps d'optimiser !
Je n'ai jamais conserver une mesure de temps dans une application réelle !


Le Passage de paramètre d'une fonction c'est complexe
En plus là, tu ne passes plus le pointeur sur la fonction mais le résultat de son appel dans les codes ci-dessus

Lit l'article de de SJRD sur les conventions d'appels et comment les bidouiller

Un autre idée, au lieu de passer la méthode directement, il faut passer une classe abstraite ou interface un peu comme le TThread

Code :

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

1
2
3
4
5
TProcess = Class(TObject)
public
  procedure Execute(); virtual; abstract;
  procedure CalcTime(AProcessName : String; Logs : TStringList);
end;

dans le code de CalcTime

Code :

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

1
2
3
4
 
// ChronoStart
Self.Execute();
// ChornoEnd

un exemple

Code :

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

1
2
3
4
5
6
7
8
9
TMonProcess = Class(TMonProcess )
private
  FParam1: Integer; 
  FParam2: string;
  FResult: Integer;
public
  constructor(AParam1: Integer; AParam2: string);
  procedure Execute(); override;
end;

Code :

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

1
2
3
4
5
6
7
 
with TMonProcess.Create(1, 'Deux') do
try
  CalcTime('...', Logs);
finally
  Free();
end;

Code :

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

1
2
3
4
procedure TMonProcess.Execute(); 
begin
  FResult := Length(Param2) - Param1);
end;

et pour simplifier l'appel, une méthode statique

Code :

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

1
2
3
4
TMonProcess = Class(TMonProcess )
...
  class function Call(AParam1: Integer; AParam2: string; AProcessName : String; Logs : TStringList): Integer;
end;

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
class function Call(AParam1: Integer; AParam2: string; AProcessName : String; Logs : TStringList): Integer;
begin
  with Self.Create(AParam1, AParam2) do
  try
    CalcTime(AProcessName, Logs);
    Result := FResult;
  finally
    Free();
  end;
end;

l'appel

Code :

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

TMonProcess.Call(1, 'Deux', '...', Logs);

EDIT avec ton exemple

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
TSetData = Class(TMonProcess)
private
  FART_ID : Integer;
  FSSF_ID : Integer;
  FResult: Integer;
public 
  constructor Create(ART_ID, SSF_ID : Integer);
  procedure Execute(); override;
 
  class function SetData(ART_ID, SSF_ID : Integer) : Integer;
end;
 
constructor TSetData.Create(ART_ID, SSF_ID : Integer);
begin
  FART_ID := ART_ID;
  FSSF_ID := SSF_ID;
end;
 
procedure TSetData.Execute(); override;
begin
  Result := FART_ID * FSSF_ID;
end;
 
class function TSetData.SetData(ART_ID, SSF_ID : Integer; AProcessName : String; Logs : TStringList): Integer;
begin
  with Self.Create(ART_ID, SSF_ID) do
  try
    CalcTime(AProcessName, Logs);
    Result := FResult;
  finally
    Free();
  end;
end;

Code :

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

1
2
3
4
5
 
procedure TCommandeClass.DoMajTable(ADoMaj : Boolean) : Boolean;
begin
  Result := TSetData.SetData(ART_ID, SSF_ID, 'SetData', FerrLogs);
end;

[Rayek]

Trop de boulot pour mettre en place cette solution.

Je comptais garder le chronométrage mais je pense que je vais le faire à la mimine et je les mettrais en commentaires

[ShaiLeTroll]

Pense au directive de compilation pour encadrer la mesure de temps et pouvoir ainsi l'activer pour des versions de test

En C++Builder, avec les macro, on peut facilement ajouter du code selon les directives de compilations, typique pour ce genre de manip, il me semblait que DelphiXE2 apportait des nouveautés sur le pré-compilateur
C'est idéal pour ce genre de code "jetable"

Peut-etre qu'avec les méthodes anonymes et les génériques, tu pourrais simplifer ma proposition, je n'ai encore jamais pratiqué cela en Delphi.

[ShaiLeTroll]

Surtout que tu risques de compter le temps de ta gestion du re-passage de paramètre (genre par pointeur sur la pile ou les trucs de SJRD dans SEPI)

Perso, je me suis fait 3 fonctions que j’utilise si j'ai ce besoin d'optimisation

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