Discussion :

[der§en]

Bonjour,

Je suis en train de chercher la meilleur façon de traiter en multitâches la création en gros volumes d'images, pour ce faire j'ai ce testé un bout de code écris par mes soins avec TTasks qui fonctionne comme je l'attends...

Par contre je suis preneur de conseils, de fiabilisations et d'améliorations de mon code, j'ai utilisé le fonction Random et Sleep pour simuler des temps d’exécutions aléatoires.

Dites-moi, si vous voyez des énormités ou s'il y a des choses que je devrais changer.

J'ai joint un zip du projet.

Merci d'avances pour vos suggestions / corrections !

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
93
94
95
96
97
98
99
100
procedure TForm1.CallBackgroundTask;
begin
  Memo1.Clear;
 
  Label3.Caption  := '0';
  Label5.Caption  := '0';
  Label10.Caption := '0';
 
  TTask.Run(procedure
  var
    I, LCycle, LCpt, LMaxi: Integer;
    LAttente: Cardinal;
    LSW: TStopWatch;
    LNbrTaches: Cardinal;
    LListTasks: Array of ITask;
  begin
    // Désactive le bouton
    ChangeButtonState;
 
    // Initialisation des variables
    LSW        := TStopwatch.StartNew;
    LNbrTaches := SpinEdit1.Value;
    LAttente   := SpinEdit2.Value;
    LMaxi      := SpinEdit1.MaxValue;
    LCycle     := 0;
    LCpt       := 0;
 
    // Défini la taille du spool de tasks
    SetLength(LListTasks, LNbrTaches);
 
    // Création du spool de Tasks
    for I := 0 to Pred(LNbrTaches) do
    begin
      LListTasks[I] := TTask.Create(procedure
      var
        LUtilisation, LIndex: Integer;
      begin
        LIndex       := TInterlocked.Increment(LCpt);
        LUtilisation := Random(LMaxi);
 
        Sleep(LUtilisation);
 
        DisplayLog(Format('Tâche %d (%d ms)', [LIndex, LUtilisation]));
      end);
    end;
 
    // Exécute les Tasks du spool
    for I := 0 to Pred(LNbrTaches) do
      LListTasks[I].Start;
 
    DisplayLog('Début');
 
    // Boucle d'attente des Tasks qui ne sont pas terminées
    while not TTask.WaitForAll(LListTasks, LAttente) do
    begin
      Inc(LCycle);
 
      Application.MainForm.Update;
    end;
 
    DisplayLog('Fin');
 
    LSW.Stop;
 
    // Affiche les stats.
    DisplayUsage(LSW.ElapsedMilliseconds, LCycle);
 
    // Ré-active le bouton
    ChangeButtonState;
  end);
end;
 
procedure TForm1.DisplayLog(const AMsg: string);
begin
  TThread.Synchronize(nil,
  procedure
  begin
    Memo1.Lines.Add(AMsg);
  end);
end;
 
procedure TForm1.ChangeButtonState;
begin
  TThread.Synchronize(nil,
  procedure
  begin
    Button1.Enabled := not Button1.Enabled;
  end);
end;
 
procedure TForm1.DisplayUsage(const AValue: Int64; const ACycle: Integer);
begin
  TThread.Synchronize(nil,
  procedure
  begin
    Label3.Caption  := AValue.ToString;
    Label5.Caption  := FormatDateTime('nn:ss.zzz', AValue / MSecsPerDay);
    Label10.Caption := ACycle.ToString;
  end);
end;

[Andnotor]

ChangeButtonState dans la tâche : à éviter. Si tu cliques frénétiquement sur le bouton CallBackgroundTask sera appelé plusieurs fois avant même qu'elle ait pu démarrer. Et puisque tu ne fait qu'inverser son état, le bouton risque bien de rester enabled.

Application.MainForm.Update devrait aussi être synchronisé (mais quel est son utilité ?) tout comme la lecture des SpinEdit (j'imagine là que c'est juste pour le test).

Sinon tu as juste codé à ta sauce un TParallel.For

[der§en]

Merci pour ton retour

Je vais effectuer une correction pour ChangeButtonState.

Pour Application.mainForm.Update, je vais regarder si je peux m’en passer.

La lecture des SpinEdit, sont juste là pour le test, en effets

La finalité n’aura rien à voir avec TParallel.For, les vrai tâches feront des traitements différents…

De mon côté, j’ai remplacé les TThread.Synchronize par TThread.Queue.

Sinon, d’autre corrections / améliorations ?

[der§en]

Petites questions pour les experts.

Il vaut mieux passer par un TThread.Queue ou bien utiliser PostMessage pour appeler un procédure contenu dans la fenêtre principale depuis un TThread ou une TTasks ?

Comment passer une string en paramètre d'un PostMessage ?

[Andnotor]

Queue est plus pratique puisqu'on peut y passer une procédure anonyme. De plus elle gérera correctement le compteur de référence à la capture d'une variable chaîne.

Une chaîne par PostMessage passe plutôt par un GetMem (un tableau de caractères) avant envoi et FreeMem à réception. Une string ne serait pas impossible (jamais essayé) mais impliquerait de gérer soi-même le compteur afin d'assurer que la chaîne existe encore après sortie de la méthode invoquant PostMessage, avec évidemment décrémentation à réception pour éviter une fuite.

[der§en]

Merci Andnotor de tes retours

Je suis partie dans une autre approche pour les chaines, dans la version que je joint ici, j'ai tout fait en PostMessage.

Dites moi si vous avez des idées d'améliorations ou de suggestions sur des problèmes potentiels ?

J'ai aussi ajouter la gestion d'un TProgressBar...

[Gouyon]

Je suis en train de chercher la meilleur façon de traiter en multitâches la création en gros volumes d'images, pour ce faire j'ai ce testé un bout de code écris par mes soins avec TTasks qui fonctionne comme je l'attends...

Si le but final est de produire plein d'images le plus rapidement possible. Il faudrait peut être déjà regarder comment ces images sont produites et voir dans quelle mesure il est possible d'accélérer ce processus. Ensuite il faut bien penser que s'il y a besoin de garder les images produites il y un risque de ralentissement de la production lié au stockage (disque, réseau...)

Si ça peut aider j'avais fait un petit article sur un couplage CUDA Delphi (https://www.developpez.net/forums/bl...a-sous-delphi/)

Et pour ce qui est de la fiabilisation, il y a des outils qui permettent de synchroniser les taches et éviter les catastrophes

[der§en]

Et pour ce qui est de la fiabilisation, il y a des outils qui permettent de synchroniser les taches et éviter les catastrophes

Je suis plus qu’intéresser pour connaître ces outils

Les images que je produites sont générées grâce à des algos, que j’ai pas mal optimisés mais je vais aussi regarder du côté de CUDA

[Gouyon]

Je suis plus qu’intéresser pour connaître ces outils

C'est essentiellement des objets de contrôle sémaphore,event,mutex... qui ont été développé pour réguler le bon déroulement des exécutions de taches en parallèle.
Par contre les possibilités sont plus large en C/C++ qu'avec les autres langages.

[der§en]

Merci de tes infos…