Main Content

Cette page a été traduite par traduction automatique. Cliquez ici pour voir la dernière version en anglais.

parfor

Exécuter des itérations for-loop en parallèle sur les Workers

réduire tous les éléments de la page

Syntaxe

parfor loopVar = initVal:endVal; statements; end
parfor (loopVar = initVal:endVal,M); statements; end
parfor (loopVar = initVal:endVal,opts); statements; end
parfor (loopVar = initVal:endVal,cluster); statements; end

Description

parfor loopVar = initVal:endVal; statements; end exécute des itérations de boucle for en parallèle sur les nœuds de calcul d'un pool parallèle.

MATLAB® exécute les commandes du corps de la boucle dans statements pour les valeurs de loopVar comprises entre initVal et endVal. loopVar spécifie un vecteur de valeurs entières augmentant de 1. Si vous disposez de Parallel Computing Toolbox™, les itérations de statements peuvent s'exécuter sur un pool parallèle de nœuds de calcul sur votre ordinateur ou cluster multicœur. Comme avec une boucle for, vous pouvez inclure une seule ligne ou plusieurs lignes dans statements.

Pour découvrir comment parfor peut vous aider à augmenter votre débit, consultez Decide When to Use parfor.

parfor diffère d'une boucle for traditionnelle des manières suivantes:

  • Les itérations de boucle sont exécutées en parallèle dans un ordre non déterministe. Cela signifie que vous devrez peut-être modifier votre code pour utiliser parfor. Pour plus d'aide, consultez Convertir les boucles for en boucles parfor.

  • Les itérations de boucle doivent être des valeurs entières consécutives et croissantes.

  • Le corps de la boucle parfor doit être indépendant. Une itération de boucle ne peut pas dépendre d'une itération précédente, car les itérations sont exécutées dans un ordre non déterministe. Pour plus d'aide, consultez Ensure That parfor-Loop Iterations are Independent.

  • Vous ne pouvez pas utiliser une boucle parfor dans une autre boucle parfor. Pour plus d'aide, consultez Nested parfor and for-Loops and Other parfor Requirements.

exemple

parfor (loopVar = initVal:endVal,M); statements; end utilise M pour spécifier le nombre maximum de nœuds de calcul du pool parallèle à utiliser pour évaluer statements dans le corps de la boucle. M doit être un entier non négatif.

Par défaut, MATLAB utilise les Workers disponibles dans votre pool parallèle. Vous pouvez modifier le nombre par défaut de nœuds de calcul dans votre pool parallèle à l'aide de la propriété PreferredPoolNumWorkers du profil par défaut. Pour tous les facteurs pouvant affecter la taille de votre pool par défaut, consultez Facteurs qui affectent la taille du pool.. Vous pouvez remplacer le nombre par défaut de nœuds de calcul dans un pool parallèle à l'aide de la fonction parpool. Lorsqu'aucun nœud de calcul n'est disponible dans le pool ou que M vaut zéro, MATLAB exécute toujours le corps de la boucle dans un ordre non déterministe, mais pas en parallèle. Utilisez cette syntaxe pour basculer entre l'exécution parallèle et série lors du test de votre code.

Avec cette syntaxe, pour exécuter les itérations en parallèle, vous devez disposer d’un pool parallèle de Workers. Par défaut, si vous exécutez parfor, vous créez automatiquement un pool parallèle de workers sur l'environnement parallèle défini par votre profil par défaut. L'environnement parallèle par défaut est Processes. Vous pouvez modifier votre profil dans Parallel Preferences. Pour plus de détails, voir Spécifiez vos préférences parallèles.

exemple

parfor (loopVar = initVal:endVal,opts); statements; end utilise opts pour spécifier les ressources à utiliser pour évaluer statements dans le corps de la boucle. Créez un ensemble d'options parfor à l'aide de la fonction parforOptions. Avec cette approche, vous pouvez exécuter parfor sur un cluster sans créer au préalable un pool parallèle et contrôler la manière dont parfor partitionne les itérations en sous-plages pour les workers.

parfor (loopVar = initVal:endVal,cluster); statements; end exécute statements sur les nœuds de calcul dans cluster sans créer de pool parallèle. Cela équivaut à exécuter parfor (loopVar = initVal:endVal,parforOptions(cluster)); statements; end.

exemple

Exemples

réduire tout

Créez une boucle parfor pour une tâche gourmande en calcul et mesurez l'accélération qui en résulte.

Dans l'éditeur MATLAB, entrez la boucle for suivante. Pour mesurer le temps écoulé, ajoutez tic et toc.

tic
n = 200;
A = 500;
a = zeros(1,n);
for i = 1:n
    a(i) = max(abs(eig(rand(A))));
end
toc

Exécutez le script et notez le temps écoulé.

Elapsed time is 31.935373 seconds.

Dans le script, remplacez la boucle for par une boucle parfor.

tic
n = 200;
A = 500;
a = zeros(1,n);
parfor i = 1:n
    a(i) = max(abs(eig(rand(A))));
end
toc

Exécutez le nouveau script et exécutez-le à nouveau. La première exécution est plus lente que la deuxième, car le pool parallèle doit être démarré et vous devez mettre le code à la disposition des workers. Notez le temps écoulé pour la deuxième exécution.

Par défaut, MATLAB ouvre automatiquement un pool parallèle de nœuds de calcul sur votre machine locale.

Elapsed time is 10.760068 seconds.

Observez que vous accélérez votre calcul en convertissant la boucle for en une boucle parfor sur quatre ouvriers. Vous pouvez réduire davantage le temps écoulé en augmentant le nombre de nœuds de calcul dans votre pool parallèle. Pour plus d’informations, consultez Convertir les boucles for en boucles parfor et Scale Up parfor-Loops to Cluster and Cloud.

Vous pouvez spécifier le nombre maximum de workers M pour une boucle parfor. Définissez M = 0 pour exécuter le corps de la boucle dans le bureau MATLAB, sans utiliser de Workers, même si un pool est ouvert. Lorsque M = 0, MATLAB exécute toujours le corps de la boucle dans un ordre non déterministe, mais pas en parallèle, afin que vous puissiez vérifier si vos boucles parfor sont indépendantes et adaptées à une exécution sur des nœuds de calcul. C'est le moyen le plus simple de vous permettre de déboguer le contenu d'une boucle parfor. Vous ne pouvez pas définir de points d'arrêt directement dans le corps de la boucle parfor, mais vous pouvez définir des points d'arrêt dans des fonctions appelées depuis le corps de la boucle parfor.

Spécifiez M = 0 pour exécuter le corps d'une boucle parfor dans le bureau MATLAB, même si un pool est ouvert.

 M = 0;                     % M specifies maximum number of workers
 y = ones(1,100);
 parfor (i = 1:100,M)
      y(i) = i;
 end

Pour contrôler le nombre de nœuds de calcul dans votre pool parallèle, consultez Spécifiez vos préférences parallèles et parpool.

Pour mesurer la quantité de données transférées vers et depuis les nœuds de calcul de votre pool parallèle actuel, ajoutez ticBytes(gcp) et tocBytes(gcp) avant et après la boucle parfor. Utilisez gcp comme argument pour obtenir le pool parallèle actuel.

Supprimez votre pool parallèle actuel si vous en avez encore un.

delete(gcp('nocreate'))
tic
ticBytes(gcp);
n = 200;
A = 500;
a = zeros(1,n);
parfor i = 1:n
    a(i) = max(abs(eig(rand(A))));
end
tocBytes(gcp)
toc

Exécutez le nouveau script et exécutez-le à nouveau. La première exécution est plus lente que la deuxième, car le pool parallèle doit être démarré et vous devez mettre le code à la disposition des workers.

Par défaut, MATLAB ouvre automatiquement un pool parallèle de nœuds de calcul sur votre machine locale.

Starting parallel pool (parpool) using the 'Processes' profile ... connected to 4 workers.
...
             BytesSentToWorkers    BytesReceivedFromWorkers
             __________________    ________________________

    1        15340                  7024                   
    2        13328                  5712                   
    3        13328                  5704                   
    4        13328                  5728                   
    Total    55324                 24168

Vous pouvez utiliser les résultats ticBytes et tocBytes pour examiner la quantité de données transférées vers et depuis les nœuds de calcul d'un pool parallèle. Dans cet exemple, le transfert de données est faible. Pour plus d'informations sur les boucles parfor, consultez Decide When to Use parfor et Convertir les boucles for en boucles parfor.

Ouvrir le live script

Créez un objet cluster à l'aide de la fonction parcluster et créez un ensemble d'options parfor avec celui-ci. Par défaut, parcluster utilise votre profil de cluster par défaut. Vérifiez votre profil par défaut dans l'onglet MATLAB Accueil, dans Parallèle > Sélectionnez Environnement parallèle.

cluster = parcluster;

Pour exécuter des calculs parfor directement dans le cluster, transmettez l'objet cluster comme deuxième argument d'entrée à parfor.

Lorsque vous utilisez cette approche, parfor peut utiliser tous les nœuds de calcul disponibles dans le cluster, et les nœuds de calcul deviennent disponibles dès que la boucle est terminée. Cette approche est également utile si votre cluster ne prend pas en charge les pools parallèles. Si vous souhaitez contrôler d'autres options, y compris le partitionnement des itérations, utilisez parforOptions.

values = [3 3 3 7 3 3 3];
parfor (i=1:numel(values),cluster)
    out(i) = norm(pinv(rand(values(i)*1e3)));
end

Utilisez cette syntaxe pour exécuter parfor sur un grand cluster sans consommer de nœuds de calcul plus longtemps que nécessaire.

Arguments d'entrée

réduire tout

Variable d'index de boucle avec la valeur initiale initVal et la valeur finale endVal. La variable peut être de n’importe quel type numérique et la valeur doit être un entier.

Assurez-vous que vos variables parfor-loop sont des entiers croissants consécutifs. Pour plus d'aide, consultez Dépanner les variables dans les boucles parfor.

La plage de la variable parfor-loop ne doit pas dépasser la plage prise en charge. Pour plus d'aide, consultez Évitez les débordements dans les boucles parfor.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Variable d'index de boucle de valeur initiale, loopVar. La variable peut être de n’importe quel type numérique et la valeur doit être un entier. Avec endVal, spécifie le vecteur de plage parfor, qui doit être de la forme M:N.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Variable d'index de boucle de valeur finale, loopVar. La variable peut être de n’importe quel type numérique et la valeur doit être un entier. Avec initVal, spécifie le vecteur de plage parfor, qui doit être de la forme M:N.

Types de données : single | double | int8 | int16 | int32 | int64 | uint8 | uint16 | uint32 | uint64

Corps de la boucle, spécifié sous forme de texte. La série de commandes MATLAB à exécuter dans la boucle parfor.

Vous devrez peut-être modifier votre code pour utiliser parfor-loops. Pour plus d'aide, consultez Convertir les boucles for en boucles parfor

N'imbriquez pas les boucles parfor, voir Nested parfor and for-Loops and Other parfor Requirements.

Nombre maximum de nœuds de calcul exécutés en parallèle, spécifié sous la forme d'un nombre entier non négatif. Si vous spécifiez une limite supérieure, MATLAB n'utilise pas plus que ce nombre, même si des workers supplémentaires sont disponibles. Si vous demandez plus de workers que le nombre de workers disponibles, alors MATLAB utilise le nombre maximum de workers disponibles au moment de l'appel. Si les itérations de la boucle sont inférieures au nombre de workers, certains workers n'effectuent aucun travail.

Si parfor ne peut pas s'exécuter sur plusieurs nœuds de calcul (par exemple, si un seul cœur est disponible ou si M vaut 0), MATLAB exécute la boucle de manière série. Dans ce cas, MATLAB exécute toujours le corps de la boucle dans un ordre non déterministe. Utilisez cette syntaxe pour basculer entre parallèle et série lors du test de votre code.

Options parfor, spécifiées en tant qu'objet ClusterOptions. Utilisez la fonction parforOptions pour créer un ensemble d'options parfor.

Exemple : opts = parforOptions(parcluster);

Cluster, spécifié en tant qu'objet parallel.Cluster, sur lequel parfor s'exécute. Pour créer un objet cluster, utilisez la fonction parcluster.

Exemple : cluster = parcluster('Processes')

Types de données : parallel.Cluster

Conseils

  • Utilisez une boucle parfor lorsque:

    • Vous disposez de nombreuses itérations de boucle d’un calcul simple. parfor divise les itérations de boucle en groupes afin que chaque thread puisse exécuter un groupe d'itérations.

    • Vous avez des itérations de boucle qui prennent beaucoup de temps à s'exécuter.

  • N'utilisez pas de boucle parfor lorsqu'une itération de votre boucle dépend des résultats d'autres itérations.

    Les réductions constituent une exception à cette règle. Une variable de réduction accumule une valeur qui dépend de toutes les itérations ensemble, mais est indépendante de l'ordre des itérations. Pour plus d’informations, consultez Reduction Variables.

  • Lorsque vous utilisez parfor, vous devez attendre la fin de la boucle pour obtenir vos résultats. Votre client MATLAB est bloqué et vous ne pouvez pas sortir de la boucle plus tôt. Si vous souhaitez obtenir des résultats intermédiaires ou sortir prématurément d'une boucle for, essayez plutôt parfeval.

  • Sauf si vous spécifiez un objet cluster, une boucle parfor s'exécute sur le pool parallèle existant. Si aucun pool n'existe, parfor démarre un nouveau pool parallèle, sauf si le démarrage automatique des pools est désactivé dans vos préférences parallèles. S'il n'y a pas de pool parallèle et que parfor ne peut pas en démarrer un, la boucle s'exécute en série dans la session client.

  • Si la propriété AutoAttachFiles dans le profil de cluster du pool parallèle est définie sur true, MATLAB effectue une analyse sur une boucle parfor pour déterminer quels fichiers de code sont nécessaires à son exécution, voir listAutoAttachedFiles. Ensuite, MATLAB attache automatiquement ces fichiers au pool parallèle afin que le code soit disponible pour les workers.

  • Vous ne pouvez pas appeler des scripts directement dans une boucle parfor. Cependant, vous pouvez appeler des fonctions qui appellent des scripts.

  • N'utilisez pas clear dans une boucle parfor car cela viole la transparence de l'espace de travail. Voir Ensure Transparency in parfor-Loops or spmd Statements.

  • Vous pouvez exécuter des modèles Simulink® en parallèle avec la commande parsim au lieu d'utiliser des parfor-loops. Pour plus d'informations et des exemples d'utilisation de Simulink en parallèle, consultez Running Multiple Simulations (Simulink).

  • Pour les calculs GPU:

    • N'utilisez pas de boucle parfor si vous disposez d'un seul GPU et que vos itérations de boucle utilisent toutes le même GPU. Les GPU contiennent de nombreux microprocesseurs capables d'effectuer des calculs en parallèle et il est peu probable que tenter de paralléliser davantage les calculs GPU à l'aide d'une boucle parfor accélère votre code.

    • Utilisez une boucle parfor si vous disposez de plusieurs GPU et que vos calculs utilisent des fonctions compatibles GPU. Pour plus d'informations sur l'utilisation de plusieurs GPU dans une boucle parfor, consultez Run MATLAB Functions on Multiple GPUs.

Capacités étendues

Historique des versions

Introduit dans R2008a

développer tout

Voir aussi

| | | | | | | | |

Rubriques