Discussion :

[Kara5]

Bonjour à tous,

J'utilise depuis quelques temps les structures sous matlab et je me pose quelques questions sur le temps de calcul...

Par flemmardise, j'organise mon script principal de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
 
p.parametre_1=xx;
p.parametre_2=xx;
 
p=fonction1(p);
 
p=fonction2(p);
 
p=fonction3(p);

et mes fonctions de la sorte :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
function p=fonction1(p)
a=parametre_1;
p.parametre_3=parametre_2+a;
end

De la sorte, étant donné que j'arrive à des programmes où j'ai une centaine de paramètres, et que, dans la phase de développement, j'ai la flemme de rajouter les paramètres en entrée et en sortie dans les différentes fonctions à chaque fois que j'en ai besoin, j'ai une grande partie de mes variables en global. Dans les fonctions, j'ai biensûr des variables locales.
Du coup, quand j'arrive à ma fonction fonction30, j'envois toutes mes variables globales à ma fonction qui elle me retourne toutes les variables globales plus les siennes calculées.

Ma question est :
Quid du temps d'exécution ? Est-ce que le fait d'envoyer toutes mes variables à chaque fois augmente mon temps de calcul ? Ou bien Matlab les considère comme des variables globales et n'y touche pas (j'entends ne réaffecte pas toute ma structure dans un nouvel espace mémoire pour ensuite tout renvoyer à la structure dans le script principal)

Merci d'avance pour vos réponses ou vos pistes.

[Jerome Briot]

Dans MATLAB, le passage d'argument à une fonction se fait par copie et non pas par adresse.

Donc en théorie, si on passe une variable qui prend N octets en mémoire, on se retrouve avec 2*N octets de mémoire utilisée, jusqu'à la fin de la fonction.

Mais MATLAB est assez malin pour éviter ceci, à la condition que les valeurs contenues dans la variable ne soient pas modifiées à l'intérieure de la fonction.

Cela fonctionne aussi en dehors des fonctions.

Voici un exemple qui crée un tableau X de 100 Mo puis une copie de ce tableau (donc 100 Mo plus en théorie) avec et sans modification :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
function test
clc
 
user = memory;
m0 = user.MemUsedMATLAB;
 
X = rand(1,13107200);
 
user = memory;
fprintf('Mémoire utilisée pour X : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
Y = X;
user = memory;
 
fprintf('Mémoire utilisée pour X et Y=X : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
Y(1) = 1;
user = memory;
 
fprintf('Mémoire utilisée si "Y(1)=1" : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
clear Y
user = memory;
 
fprintf('Mémoire utilisée si "clear Y": %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)

Ce qui donne :

Mémoire utilisée pour X : 100 Mo
Mémoire utilisée pour X et Y=X : 100 Mo
Mémoire utilisée si "Y(1)=1" : 200 Mo
Mémoire utilisée si "clear Y": 100 Mo

Dans le cas des structures et des tableaux de cellules, chaque champs ou chaque élément se comporte à peu près comme un tableau indépendant.

En reprenant l'exemple précédent :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
function test
clc
 
user = memory;
m0 = user.MemUsedMATLAB;
 
X{1} = rand(1,13107200);
X{2} = rand(1,13107200);
 
user = memory;
fprintf('Mémoire utilisée pour X : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
Y = X;
user = memory;
 
fprintf('Mémoire utilisée pour X et Y=X : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
Y{1}(1) = 1;
user = memory;
 
fprintf('Mémoire utilisée si "Y{1}(1)=1" : %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)
 
clear Y
user = memory;
 
fprintf('Mémoire utilisée si "clear Y": %.0f Mo\n', (user.MemUsedMATLAB-m0)/1024/1024)

ce qui donne :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
Mémoire utilisée pour X : 200 Mo
Mémoire utilisée pour X et Y=X : 200 Mo
Mémoire utilisée si "Y{1}(1)=1" : 300 Mo
Mémoire utilisée si "clear Y": 200 Mo

Lorsqu’on modifie l'élément Y{1}, seul cet élément est dupliqué en mémoire, pas la totalité du tableau de cellules.

Maintenant, si tu emploies des variables globales, il n'y a plus à tenir compte de ces effets. Les variables ne sont pas dupliquées.

[Kara5]

Merci, c'était exactement ce genre de réponse que j'attendais.

[shaiHulud]

Bonjour,

Si ta structure d'options est une dynamicprop() plutot qu'une simple struct, tu obtiens un passage par référence plutôt que par valeur (donc sans copie)

Mais MATLAB est assez malin pour éviter ceci, à la condition que les valeurs contenues dans la variable ne soient pas modifiées à l'intérieure de la fonction

Pour autant, on ne sait pas trop quand va se faire la copie. J'ai parfois l'impression qu'elle se fait avant la modification de l'argument par la fonction.

Par exemple, je prends un x très gros en mémoire et m=0. La fonction suivante provoque un out of memory quand j'appelle f(x,0), mais n'en provoque plus quand je passe un handle pour l'argument x (alors que l'argument n'est PAS modifié par la fonction)

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
function f(x,m)
if m; x=x+1;end

EDIT: le cas auquel je pense est en réalité un peu plus complexe que cette simple fonction. J’essaierai de le retrouver.

[Jerome Briot]

La fonction suivante provoque un out of memory quand j'appelle f(x,0), mais n'en provoque plus quand je passe un handle pour l'argument x (alors que l'argument n'est PAS modifié par la fonction)

Je n'arrive pas à reproduire ceci sur ma machine... trop de mémoire disponible

J'essaierai de tester avec une autre en 32 bits