J'ai lu que si, par exemple, j'ai une double forboucle qui court sur les index d'une matrice, alors mettre l'index courant de la colonne dans la boucle externe est plus efficace. Par exemple:
a=zeros(1000);
for j=1:1000
for i=1:1000
a(i,j)=1;
end
endQuelle est la manière la plus efficace de la coder si j'ai trois forboucles ou plus ?
Par exemple:
a=zeros(100,100,100);
for j=1:100
for i=1:100
for k=1:100
a(i,j,k)=1;
end
end
end
matlab
efficiency
TensoR
la source
la source
Forles boucles sont très lentes dans MATLAB. Vous devez éviter autant que possible les boucles explicites dans MATLAB. Au lieu de cela, un problème peut généralement être exprimé en termes d'opérations matricielles / vectorielles. C'est la voie MATLABique. Il y a aussi beaucoup de fonctions intégrées pour initialiser les matrices, etc. Par exemple, il y a une fonction, ones () , qui mettra tous les éléments d'une matrice à 1 (par extension, à n'importe quelle valeur par multiplication (un scalaire multiplié par la matrice tout-en-un)). Il fonctionne également sur les tableaux 3D (qui je pense couvre l'exemple ici).Réponses:
Réponse courte, vous voulez avoir l'index le plus à gauche sur la boucle la plus à l'intérieur. Dans votre exemple, les indices de boucle iraient k, j, i et les indices de tableau seraient i, j, k. Cela a à voir avec la façon dont MATLAB stocke les différentes dimensions en mémoire. Pour en savoir plus, voir # 13 de ce post reddit .
la source
Une réponse un peu plus longue qui explique pourquoi il est plus efficace que l'indice le plus à gauche varie le plus rapidement. Vous devez comprendre deux éléments clés.
Premièrement, MATLAB (et Fortran, mais pas C et la plupart des autres langages de programmation) stocke les tableaux en mémoire dans "l'ordre majeur des colonnes". Par exemple, si A est une matrice 2 x 3 x 10, les entrées seront stockées en mémoire dans l'ordre
A (1,1,1)
A (2,1,1)
A (1,2,1)
A (2,2,1)
A (1,3,1)
A (2,3,1)
A (1,1,2)
A (2,1,2)
...
A (2,3,10)
Ce choix de l'ordre majeur des colonnes est arbitraire - nous pourrions simplement adopter une convention "ordre majeur des lignes", et en fait c'est ce qui se fait en C et dans d'autres langages de programmation.
La deuxième chose importante que vous devez comprendre est que les processeurs modernes n'accèdent pas à la mémoire un emplacement à la fois, mais chargent et stockent plutôt des "lignes de cache" de 64 voire 128 octets contigus (8 ou 16 nombres à virgule flottante double précision) à la fois de mémoire. Ces morceaux de données sont temporairement stockés dans une mémoire cache rapide et réécrits au besoin. (Dans la pratique, l'architecture du cache est maintenant assez compliquée avec jusqu'à 3 ou 4 niveaux de mémoire cache, mais l'idée de base peut être expliquée avec un cache à un niveau du type que les ordinateurs avaient dans ma jeunesse.)
Si les boucles sont imbriquées de sorte que la boucle la plus interne met à jour l'indice de ligne, alors les entrées du tableau seront accessibles dans l'ordre A (1,1), A (2,1), A (3,1), ... la première entrée A (1,1) est accessible, le système apportera une ligne de cache contenant A (1,1), A (2,1), ..., A (8,1) dans le cache depuis la mémoire principale . Les 8 itérations suivantes de la boucle la plus intérieure fonctionnent sur ces données sans aucun transfert de mémoire principale supplémentaire.
Si dans l'alternative, nous structurons les boucles de sorte que l'index de colonne varie dans la boucle la plus intérieure, alors les entrées de A seraient accessibles dans l'ordre A (1,1), A (1,2), A (1,3 ), ... Dans ce cas, le premier accès amènerait A (1,1), A (2,1), ..., A (8,1) dans le cache depuis la mémoire principale, mais 7/8 de ces entrées ne seraient pas utilisées. L'accès à A (1,2) dans la deuxième itération apporterait alors 8 entrées supplémentaires depuis la mémoire principale, et ainsi de suite. Au moment où le code s'est mis à travailler sur la ligne 2 de la matrice, l'entrée A (2,1) pourrait bien être supprimée du cache pour faire place à d'autres données nécessaires. En conséquence, le code génère 8 fois plus de trafic que nécessaire.
Certains compilateurs d'optimisation sont capables de restructurer automatiquement les boucles pour éviter ce problème.
De nombreux algorithmes d'algèbre linéaire numérique pour la multiplication matricielle et la factorisation peuvent être optimisés pour fonctionner efficacement avec le schéma de commande ligne par ligne ou colonne par ligne en fonction du langage de programmation. Faire cela dans le mauvais sens peut avoir un impact négatif significatif sur les performances.
la source