Dans MATLAB, la boucle parfor est un outil puissant pour paralléliser les tâches intensives en calcul. Bien employée, elle réduit considérablement les temps d'exécution ; mal employée, elle produit des résultats faux sans prévenir. Voici comment en tirer le meilleur parti.
1. Comprendre parfor et ses contraintes
parfor exécute les itérations d'une boucle en parallèle sur plusieurs workers d'un pool MATLAB, créé avec parpool.
Indépendance des itérations. C'est la règle cardinale. Les itérations doivent être mutuellement indépendantes : aucune ne peut lire une donnée écrite par une autre, ni écrire une donnée qu'une autre lira. La violation de ce principe est la première cause de bugs, et elle ne se manifeste pas toujours de façon visible.
Classement des variables. MATLAB répartit les variables en plusieurs catégories :
- variable de boucle : l'indice, comme
idansparfor i = 1:n; - tranche de variable de boucle : une variable simple ne dépendant pas de l'indice ;
- variable de diffusion : définie avant la boucle, lue mais non modifiée à l'intérieur, elle est partagée en lecture par tous les workers ;
- variable de réduction : elle accumule un résultat au fil des itérations et requiert un traitement particulier ;
- variable temporaire : créée dans la boucle, privée à chaque worker, sans utilité en dehors ;
- variable indexée :
A(i)ouB{i}, dont le classement dépend de l'usage.
Restrictions d'indexation. L'index doit dépendre directement de la variable de boucle. Une indexation imbriquée du type A(B(i)) pose problème, et écrire dans le même indice depuis plusieurs itérations est interdit.
Appels de fonction. Appeler des fonctions externes, surtout non écrites en langage MATLAB, introduit des goulots de sérialisation qui annulent une partie du gain parallèle. Incrinez le code lorsque c'est possible.
Espaces de travail distincts. Chaque worker possède le sien. Les variables créées dans la boucle disparaissent à la sortie, sauf s'il s'agit de variables de réduction ou renvoyées via la tranche de la variable de boucle.
2. Les étapes d'optimisation
Identifier les sections parallélisables
Repérez les boucles for dont les itérations effectuent des calculs indépendants. Analysez les dépendances de données : parfois une légère réorganisation de l'algorithme suffit à rendre le code parallélisable.
Convertir et laisser MATLAB vérifier
parfor i = 1:n
% votre code
end
À la compilation, MATLAB analyse la boucle et signale avertissements ou erreurs en cas de dépendance détectée. Lisez ces messages avec attention : ils sont votre meilleur garde-fou.
Gérer les variables de réduction
Pour combiner les résultats des itérations, MATLAB prend en charge nativement les opérations de réduction usuelles :
x = x + expression; % somme x = x * expression; % produit x = [x, expr]; % concaténation par colonne x = [x; expr]; % concaténation par ligne x = min(x, expr); % minimum x = max(x, expr); % maximum x = x && expr; % ET logique x = x || expr; % OU logique
Exemple :
n = 1000;
resultat = 0; % à initialiser AVANT la boucle
parfor i = 1:n
resultat = resultat + i^2; % variable de réduction
end
disp(resultat);
Pré-allouer les tableaux
Si vous écrivez dans un tableau à l'intérieur de la boucle, pré-allouez-le avant. Le redimensionnement répété constitue un goulot majeur, particulièrement pénalisant en parallèle.
n = 1000;
resultats = zeros(1, n);
parfor i = 1:n
resultats(i) = i^2;
end
Réduire les transferts de données
Les échanges entre le client MATLAB et les workers pèsent lourd. Déclarez les grandes variables d'entrée en lecture seule avant la boucle pour qu'elles soient correctement classées en variables de diffusion, et évitez toute communication superflue.
Régler le nombre de workers
Le nombre optimal dépend du problème, du matériel et du surcoût de parallélisation. Testez plusieurs configurations avec parpool et servez-vous de gcp pour connaître la taille du pool courant. Lancer davantage de workers que de cœurs physiques n'améliore généralement pas les performances et peut les dégrader par surcoût de commutation de contexte.
Profiler
Utilisez le profileur MATLAB (profile on, profile off, profile viewer) pour localiser les points chauds, en prêtant une attention particulière au temps passé en communication et en transfert de données.
Exemple : estimation de π par Monte-Carlo
n = 1e7;
% Version séquentielle
tic
inside_circle = 0;
for i = 1:n
x = rand();
y = rand();
if x^2 + y^2 <= 1
inside_circle = inside_circle + 1;
end
end
pi_serial = 4 * inside_circle / n;
t_serial = toc;
% Version parallèle correcte (avec réduction)
tic
parpool;
inside_par = 0;
parfor i = 1:n
x = rand();
y = rand();
if x^2 + y^2 <= 1
inside_par = inside_par + 1; % variable de réduction
end
end
delete(gcp('nocreate'));
pi_par = 4 * inside_par / n;
t_par = toc;
disp(['Pi (séquentiel) : ' num2str(pi_serial) ' Temps : ' num2str(t_serial)]);
disp(['Pi (parfor) : ' num2str(pi_par) ' Temps : ' num2str(t_par)]);
Une version parallèle naïve, où inside_par serait incrémentée sans être déclarée comme variable de réduction, s'exécuterait en parallèle mais produirait un résultat faux : plusieurs workers modifieraient simultanément la même variable et des mises à jour seraient perdues. La forme inside_par = inside_par + 1 indique à MATLAB d'accumuler correctement les contributions de chaque worker, sans condition de concurrence. Le pool est ouvert avant la boucle et refermé ensuite par delete(gcp('nocreate')), le paramètre 'nocreate' évitant qu'un pool soit créé par accident.
Dépannage
Conditions de concurrence. L'erreur la plus fréquente reste l'écriture simultanée au même emplacement mémoire. MATLAB tente de les détecter, mais certaines formes sont subtiles.
Débogage. Les boucles parfor se déboguent mal. Commencez avec un petit nombre d'itérations pour isoler les problèmes, et posez vos points d'arrêt avec discernement.
Surcoût. Si le calcul par itération est très léger, la parallélisation peut coûter plus qu'elle ne rapporte. Mesurez toujours.
Limites matérielles. Le nombre de workers doit rester inférieur ou égal au nombre de cœurs physiques disponibles.
Version de MATLAB. Le comportement de parfor et de la Parallel Computing Toolbox évolue d'une version à l'autre. Reportez-vous à la documentation officielle correspondant à votre installation.
En respectant ces règles et en comprenant les limites de parfor, vous gagnerez des gains de performance substantiels sur les tâches gourmandes en calcul — à condition de toujours valider l'exactitude des résultats par un test approfondi.