Code parallèle

stock}}

La programmation parallèle permet de distribuer des boucles de traitement sur l'ensemble des coeurs disponibles.

Près-requis

Pour être parallélisable une boucle de traitement doit vérifier les conditions suivantes :

• Chaque exécution du corps de boucle doit être indépendante.

Il n'existe pas de mécanisme de synchronisation de sorte que les exécutions parallèles ne doivent pas partager d'objet ou de variable.

• La boucle doit utiliser un pattern de code

Les patterns de code implémente le mécanisme le synchronisation des différents exécuteurs.

• La boucle de traitement doit appeler une méthode qui exécute la tâche.

Ce sont l'exécution des méthodes qui sont parallélisées.

Pool d'exécuteur

L'exécution d'une méthode en parallèle est pris en charge par des exécuteurs (working thread) qui sont gérés en pool. La taille de ce pool est déterminé par le nombre de coeurs disponibles et la configuration réseau.

La taille de ce pool est déterminé automatiquement, toutefois à des fin de test il est possible de changer celle-ci dans le dialogue de préférence du concepteur de modèle onglet "Réglages"

Mot clé "parallel"

Ce mot clé se place devant l'appel d'une méthode pour indiquer au compilateur de générer l'appel parallèle.

<source lang="delphi"> var tk:Int64; begin

 tk := GetTickCount;
 try
 withP Transaction do
 for var idx:=1 to 10 do
  begin
   parallel doCreateA(idx);
  end;
 finally
 tk := GetTickCount-tk;
 showmessage(Format('%s ms',[TickToString(tk)]));
 end;

end; </source>

Paramètres des méthodes parallélisées

Lorsqu'une méthode est exécutée en parallèle ses paramètres sont copiés dans le contexte de l'exécuteur.

Certain paramètres sont gérés avec attention :

• Les objets sont tenus par référence et non pas par copie.
• les liste d'objet sont dupliquées (mais pas les objets qu'elles contiennent)

Exemple :

Dans cet exemple une liste d'objet a traité est passé à la méthode doProcessList, cette liste est ensuite réinitialisée sans que cela impacte l'exécution en cours de l'exécuteur.

<source lang="delphi"> var list:WFClasseAList; inst:WFClasseA; cursor:WFClasseACursor; count:Integer; tk:Int64; begin

 List := WFClasseA.CreateList;
 Cursor := WFClasseA.CreateCursorWhere(,,true,['A',1]);
 tk := GetTickCount;
 try
 foreachP inst in cursor index count with long transaction do
  begin
    List.AddRef(inst);
    if List.Count=100 then
     begin
       // start a working thread
       parallel doProcessList(List);
       // list.Clear is safe because the list has been cloned
       List.Clear;
     end;
  end;
 finally
 tk := GetTickCount-tk;
 showmessage(Format('%d %s ms',[count,TickToString(tk)]));
 end;

end; </source>

Partage de transaction

Les transactions peuvent être partagées lors d'une exécution parallèle.

Exemple : Une seul transaction partagée :

<source lang="delphi"> //Procedure doCreateA(index:Integer); var inst:WFClasseA; begin

 // share the transaction
 inst := WFClasseA.Create;
 inst.unCode := 'X'+inttostr(index);
 inst.Caption := 'Objet A'+inttostr(index);
 inst.unEntier := 1+Trunc(Random(100));

end;

//Procedure CreateSomeA; var tk:Int64; begin

 tk := GetTickCount;
 try
 withP Transaction do
 for var idx:=1 to 10 do
  begin
   parallel doCreateA(idx);
  end;
 finally
 tk := GetTickCount-tk;
 showmessage(Format('%s ms',[TickToString(tk)]));
 end;

end; </source>

Exemple : Un transaction par exécuteur :

<source lang="delphi"> //Procedure doCreateA(index:Integer); var inst:WFClasseA; begin

 // share the transaction
 with  Transaction do
  begin
    inst := WFClasseA.Create;
    inst.unCode := 'X'+inttostr(index);
    inst.Caption := 'Objet A'+inttostr(index);
    inst.unEntier := 1+Trunc(Random(100));
  end;

end;

//Procedure CreateSomeA; var tk:Int64; begin

 tk := GetTickCount;
 try
 for var idx:=1 to 10 do
  begin
   parallel doCreateA(idx);
  end;
 finally
 tk := GetTickCount-tk;
 showmessage(Format('%s ms',[TickToString(tk)]));
 end;

end; </source>

Messages émis par le code

Le code exécuté en parallèle peut [ProgressMessage_(ihm)|émettre des messages] vers l'interface utilisateur.

Du fait du parallélisme l'ordre d'apparition des messages ne peut pas être garanti.

Tip : La collecte des messages est réalisée par une thread qui se synchronise avec l'interface utilisateur.

Interruption du traitement

Lorsqu'une boucle parallélisée est interrompue, par exemple par une instruction break, l'interruption ne sera effective qu'à la fin des exécutions déjà démarrées. En d'autre terme les exécutions déjà lancées se poursuivent.

<source lang="delphi"> begin

 ...
 foreachP I in C index ACount on except continue do
  begin
    // check abort
    if UserAbort then
     begin
       doLogFailure(nil,S,_TP('Traitement interrompu'));
       break;
     end;
    ....
  end;
  // all working thread terminated even if a break has occured.

end; </source>

Gestion des exceptions

Les exceptions qui se produisent dans un exécuteur sont capturées, la prise en compte dans la boucle principale dépend du mode de gestion de celle-ci.

• Mode break

L'exception arrête la boucle est re-déclenchée dans la boucle principale (main thread)

• Mode continue

L'exécution est capturée et ignorée.

Imbrication

L'exécution parallèle peut être imbriquée, c'est qu'une méthode exécutée en parallèle peut elle même exécutée une boucle parallélisée.