Discussion :

[odaumasXLog]

Bonjour à tous et à toutes.

Je suis sur un problème un peu énervant que j'aimerais vous faire partager. Il n'y a pas de raison que je sois le seul à être énervé un vendredi .

Je suis dans l'exécution d'un thread que je veux répéter toutes les secondes (en tenant compte du temps de traitement, cela va sans dire).
Je code donc :

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
 
 
  while not Terminated do
    begin
      StartTime := GetTickCount;    //début des manoeuvres
 
      Mon traitement;
      Synchronize('MonInterface');
 
      //  ElapsedTime := (1000 - (GetTickCount - StartTime));   //Je décompte le temps de traitement (GetTickCount - StartTime) de ma seconde
      //Sleep(ElapsedTime);                                                    //j'attends le temps nécessaire 
                                                                                         //OU (j'ai dépensé mon temps sans compter)
      while GetTickCount < (StartTime + 1000) do                  //je boucle tant que je ne suis pas arrivé à tps de traitement + ma seconde
        begin
        end;
    end;

Le problème est que, après avoir essayé des trucs que j'ai trop honte de vous rapporter, j'arrive toujours à une différence de 13 ou 14 milisecondes , des fois un peu plus, un peu moins, mais rarement.
Quelqu'un pourrait-il m'expliquer pouquoi ?

Merci d'avance.

[Andnotor]

C'est normal, GetTickCount se base sur le clock système qui survient toutes les N millisecondes (environ 12 ms de mémoire). Il faut passer par un compteur de précision :

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
function GetTickCountEx :Extended;
var
  Frequency :Int64;
  Counter   :Int64;
 
begin
  //Si le compteur de précision n'est pas disponible
  //utilise GetTickCount converti en seconde.
  if QueryPerformanceFrequency(Frequency) then
  begin
    QueryPerformanceCounter(Counter);
    Result := Counter /Frequency;
  end
  else Result := GetTickCount *1000;
end;

Cela dit, lancer une boucle d'attente va bloquer un cœur du CPU pour cette seule tâche. Tu pénalises le système global.
Sleep de son côté va rendre la main mais sans savoir exactement quand il pourra la récupérer (plus la priorité du processus/thread sera haute, plus ce sera rapide).

Pas sûr que tu arrives à tes fins...

[odaumasXLog]

Bonjour et merci pour ton aide Andnotor.

Tu m'as donné le principal, l'explication du pourquoi.
Néanmoins, j'ai essayé d'appliquer ton exemple, mais j'arrive à des écarts bien plus importants.
Suivant ton conseil, j'ai préféré remettre Sleep(ElapsedTime);
Pour le reste, j'ai gardé GetTickCount qui me met 12 ms (en fait, j'ai des différences de 13 ou 14 le plus souvent) dans les dents à chaque boucle de thread. Ce qui est très acceptable sur une boucle de 1 s, à condition que je sache pourquoi .

Merci encore et bon WE

[ShaiLeTroll]

Tu peux aussi utiliser un TEvent qui a un délai de 1s !

Voici le corps de la méthode Execute du TThread.
Dans ton cas, tu n'exploites que le wrTimeout mais le wrSignaled peut être utilisé pour gérer le Terminate.

De plus, si ton traitement dure moins longtemps que le délai et que tu veux garantir une exécution toutes les secondes,
tu affectes à FDelay 1s - temps de traitement et donc c'est pas Sleep(ElapsedTime); mais Sleep(1000 - ElapsedTime).

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
   while not Terminated do
  begin
    wr := FSignal.WaitFor(FDelay);
    case wr of
      wrSignaled:
        begin
          // Si l'on arrête le Batch, on ne traite pas les fichiers
          if not Terminated then
            Process();
        end;
      wrTimeout:
        begin
          // Si l'on arrête le Batch, on ne se préoccupe plus de l'inactivité !
          if not Terminated then
            Idle();
        end;
    end;
  end;

Code :

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

1
2
3
4
5
6
7
8
//------------------------------------------------------------------------------
procedure TAutomateLogistiqueSDIFileProcessor.TerminatedSet();
begin
  inherited TerminatedSet();
 
  if Assigned(FSignal) then
    FSignal.SetEvent(); // Arrêt prématuré !
end;