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

parfor

Exécuter des itérations de boucle for en parallèle sur les workers

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 workers 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 avez Parallel Computing Toolbox™, les itérations de statements peuvent s'exécuter sur un pool parallèle de workers sur votre ordinateur multicœur ou cluster. 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 Décider quand utiliser 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, voir Convertir les boucles for en boucles parfor .

• Les itérations de boucle doivent être consécutives et avoir des valeurs entières 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, voir Ensure That parfor-Loop Iterations Are Independent .

• Vous ne pouvez pas utiliser une boucle parfor à l'intérieur d'une autre boucle parfor. Pour plus d'aide, voir Boucles imbriquées parfor et for et autres exigences parfor .

parfor (loopVar = initVal:endVal,M); statements; end Utilisez M pour spécifier le nombre maximal de workers 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 workers 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, voir Facteurs qui affectent la taille du pool . Vous pouvez remplacer le nombre par défaut de workers dans un pool parallèle en utilisant la fonction parpool. Lorsqu'aucun worker n'est disponible dans le pool ou que M est nul, 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écifier vos préférences pour le traitement parallèle .

parfor (loopVar = initVal:endVal,opts); statements; end utilise opts pour spécifier les ressources à utiliser dans l'évaluation de 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 workers dans cluster sans créer de pool parallèle. Ceci est équivalent à l'exécution de parfor (loopVar = initVal:endVal,parforOptions(cluster)); statements; end .

Exemples

Convertir une boucle for en boucle parfor

Créez une boucle parfor pour une task 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é, additionnez 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, puis 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 rendre le code disponible pour les workers. Notez le temps écoulé pour la deuxième course.

Par défaut, MATLAB ouvre automatiquement un pool parallèle de workers sur votre machine locale.

Elapsed time is 10.760068 seconds. 

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

Tester les boucles parfor en basculant entre l'exécution parallèle et l'exécution série

Vous pouvez spécifier le nombre maximal de workers M pour une boucle parfor. Définissez M = 0 pour exécuter le corps de la boucle sur le desktop 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 à l'exécution sur les workers. C'est la manière la 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 sur le desktop 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 workers dans votre pool parallèle, consultez Spécifier vos préférences pour le traitement parallèle et parpool.

Mesurer les données transférées aux workers à l'aide d'une boucle parfor

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 toujours 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, puis 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 rendre le code disponible pour les workers.

Par défaut, MATLAB ouvre automatiquement un pool parallèle de workers 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 workers d'un pool parallèle. Dans cet exemple, le transfert de données est faible. Pour plus d'informations sur les boucles parfor, voir Décider quand utiliser parfor et Convertir les boucles for en boucles parfor .

Exécuter parfor sur un cluster sans pool parallèle

Créez un objet cluster à l’aide de la fonction parcluster et créez un ensemble d’options parfor avec lui. 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électionner 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 workers disponibles dans le cluster, et les workers 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 workers plus longtemps que nécessaire.

Arguments d'entrée

loopVar — Indice de boucle

entier

Variable d'index de boucle avec valeur initiale initVal et 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 de boucle parfor sont des entiers consécutifs croissants. Pour plus d'aide, voir Dépannage des 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, voir Éviter les débordements dans les boucles parfor .

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

initVal — Valeur initiale de l'index de boucle

entier

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

endVal — Valeur finale de l'indice de boucle

entier

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

statements — Corps de boucle

texte

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 les boucles parfor. Pour plus d'aide, voir Convertir les boucles for en boucles parfor

N'imbriquez pas les boucles parfor, voir Boucles imbriquées parfor et for et autres exigences parfor .

M — Nombre maximal de workers exécutés en parallèle

nombre de workers dans le pool parallèle (par défaut) | entier non négatif

Nombre maximal de workers exécutés en parallèle, spécifié sous la forme d'un 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 maximal 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 workers (par exemple, si un seul cœur est disponible ou si M est 0), MATLAB exécute la boucle de manière sérielle. 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.

opts — options de parfor

Objet parforOptions

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

Exemple : opts = parforOptions(parcluster);

cluster — Cluster

parallel.Cluster

Cluster, spécifié comme un 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 à 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 sont 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 d'itération. Pour plus d'informations, voir Reduction Variables.

• Lorsque vous utilisez parfor, vous devez attendre que la boucle se termine 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.

• À moins que vous ne spécifiiez 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 pour le 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 de 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 les modèles Simulink^® en parallèle avec la commande parsim au lieu d'utiliser les boucles parfor. Pour plus d'informations et d'exemples d'utilisation de Simulink en parallèle, voir Running Multiple Simulations (Simulink) .

• Pour les calculs GPU :

  • N'utilisez pas de boucle parfor si vous avez un seul GPU et que vos itérations de boucle utilisent toutes le même GPU. Les GPU contiennent de nombreux microprocesseurs qui peuvent effectuer des calculs en parallèle et essayer de paralléliser davantage les calculs GPU à l'aide d'une boucle parfor est peu susceptible d'accélérer 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, voir Run MATLAB Functions on Multiple GPUs .

Capacités étendues

Environnement basé sur les threads

Exécutez du code en arrière-plan avec MATLAB® backgroundPool ou accélérez le code avec Parallel Computing Toolbox™ ThreadPool.

Cette fonction prend entièrement en charge les environnements basés sur les threads. Pour plus d'informations, voir Run MATLAB Functions in Thread-Based Environment.

Historique des versions

Introduit dans R2008a

R2024b: Utiliser des expressions d'indexation de vecteurs à deux points avec des variables découpées

À partir de R2024b, vous pouvez désormais utiliser des expressions d'indexation de vecteurs deux-points pour indexer les variables d'entrée et de sortie découpées en tranches dans les boucles parfor. L'expression d'indexation du vecteur deux-points doit être sous la forme j:k ou j:k:l .

Par exemple, pour affecter des valeurs uniquement aux colonnes 3 à 7 de la variable de sortie out, utilisez le vecteur 3:7 comme indice lorsque vous indexez la variable découpée.

out = zeros(10);
parfor i = 1:10
    out(i,3:7) = rand(1,5);
end

Vous pouvez utiliser soit des variables de diffusion simples, soit des constantes entières scalaires dans les expressions d'indexation de vecteurs deux-points. Les variables temporaires ou les expressions compliquées ne sont pas prises en charge.

R2024a: Spécifier le nombre maximal de threads workers dans la boucle parfor

À partir de R2024a, vous pouvez désormais spécifier le nombre maximal de workers lors de l'exécution de parfor-loops sur un pool parallèle basé sur des threads.

Voir aussi

for | gcp | listAutoAttachedFiles | parpool | parfeval | ticBytes | tocBytes | send | afterEach | parforOptions

Rubriques

• Décider quand utiliser parfor
• Convertir les boucles for en boucles parfor
• Ensure That parfor-Loop Iterations Are Independent
• Boucles imbriquées parfor et for et autres exigences parfor
• Dépannage des variables dans les boucles parfor
• Scale Up parfor-Loops to Cluster and Cloud
• Spécifier vos préférences pour le traitement parallèle
• Run Parallel Simulations (Simulink)