Discussion :

[Aleph69]

Bonjour,

je me pose une question à propos de matlab concernant le passage des tableaux en paramètre de fonctions : des copies temporaires sont-elles faites?

Par exemple, si j'ai une fonction toto prenant en argument un tableau et que je fais l'appelle toto(array(1:2)), est-ce qu'une copie de array(1:2) est stockée localement quelque part?

Merci pour votre aide.

[Buide]

Je pense que la réponse est oui.

Dans ta fonction tu travailleras sur une copie locale du tableau. D'ailleurs si tu utilise le "débuggeur" tu verras que quand tu passes dans une fonction, tu as un workspace local composé seulement des variables utilisé par la fonction.

D'ailleurs une simple fonction:

Code :

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

1
2
3
function [b]=addone(b);
b=b+1;
end

Si tu l'apelles avec H2=addone(H), H ne changeras pas.

Je sais pas si c'est ce que tu voulais savoir.

[Aleph69]

Merci pour ta réponse.
Oui, c'est bien cela qui m'intéresse.
En fait, je sais que si je modifie localement la variable, il y a copie locale mais je me demandais ce qui se passait lorsque je ne modifie rien... mais bon il ne faut pas trop rêver c'est du script.
Est-ce qu'il y a une technique pour éviter ces copies parce que je dois manipuler des tableaux relativement volumineux et je ne pas me permettre de faire de telles copies?

[Jerome Briot]

Je me permets d'essayer de faire une réponse plus générale... en essayant de faire court quand même et sans dire trop de bêtises

Prenons le cas d'une variable X de 100 Mo.

Tout d'abord ce script :

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
clear all
 
user = memory;
M(1) = round(user.MemUsedMATLAB/1024/1024);
 
X = rand(1,13107200);
 
user = memory;
M(2) = round(user.MemUsedMATLAB/1024/1024);
 
Y = X;
 
user = memory;
M(3) = round(user.MemUsedMATLAB/1024/1024);
 
Y(1) = 2;
 
user = memory;
M(4) = round(user.MemUsedMATLAB/1024/1024);
 
clc
 
fprintf('Memoire utilisee par MATLAB au depart : %d Mo\n',M(1));
fprintf('Memoire utilisee par MATLAB en creant X de taille 100 Mo : %d Mo\n',M(2));
fprintf('Memoire utilisee par MATLAB en creant Y ( Y = X) : %d Mo\n',M(3));
fprintf('Memoire utilisee par MATLAB en modifiant Y ( Y(1) = 2) : %d Mo\n',M(4));

renvoie sur ma machine :

Code :

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

1
2
3
4
Memoire utilisee par MATLAB au depart : 345 Mo
Memoire utilisee par MATLAB en creant X de taille 100 Mo : 445 Mo
Memoire utilisee par MATLAB en creant Y ( Y = X) : 445 Mo
Memoire utilisee par MATLAB en modifiant Y ( Y(1) = 2) : 545 Mo

Tant que la copie n'est pas modifiée, la quantité de mémoire n'est pas augmentée

En utilisant des fonctions :

Code :

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

1
2
3
4
function m = test(Y)
 
user = memory;
m = round(user.MemUsedMATLAB/1024/1024);

Code :

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

1
2
3
4
5
function m = test2(Y)
 
Y(1) = 2;
user = memory;
m = round(user.MemUsedMATLAB/1024/1024);

On lance le script suivant :

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
clear all
 
user = memory;
M(1) = round(user.MemUsedMATLAB/1024/1024);
 
X = rand(1,13107200);
 
user = memory;
M(2) = round(user.MemUsedMATLAB/1024/1024);
 
M(3) = test(X);
 
M(4) = test2(X);
 
clc
 
fprintf('Memoire utilisee par MATLAB au depart : %d Mo\n',M(1));
fprintf('Memoire utilisee par MATLAB en creant X de taille 100 Mo : %d Mo\n',M(2));
fprintf('Memoire utilisee par MATLAB en exécutant la fonction test : %d Mo\n',M(3));
fprintf('Memoire utilisee par MATLAB en modifiant la fonction test2 : %d Mo\n',M(4));

On obtient :

Code :

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

1
2
3
4
Memoire utilisee par MATLAB au depart : 345 Mo
Memoire utilisee par MATLAB en creant X de taille 100 Mo : 445 Mo
Memoire utilisee par MATLAB en exécutant la fonction test : 445 Mo
Memoire utilisee par MATLAB en modifiant la fonction test2 : 545 Mo

Pareil que précédemment

Maintenant, si on passe une partie seulement de X :

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
clear all
 
user = memory;
M(1) = round(user.MemUsedMATLAB/1024/1024);
 
X = rand(1,13107200);
 
user = memory;
M(2) = round(user.MemUsedMATLAB/1024/1024);
 
M(3) = test(X(1:2:end));
 
M(4) = test2(X(1:2:end));
 
clc
 
fprintf('Memoire utilisee par MATLAB au depart : %d Mo\n',M(1));
fprintf('Memoire utilisee par MATLAB en creant X de taille 100 Mo : %d Mo\n',M(2));
fprintf('Memoire utilisee par MATLAB en exécutant la fonction test : %d Mo\n',M(3));
fprintf('Memoire utilisee par MATLAB en modifiant la fonction test2 : %d Mo\n',M(4));

On obtient :

Code :

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

1
2
3
4
Memoire utilisee par MATLAB au depart : 345 Mo
Memoire utilisee par MATLAB en creant X de taille 100 Mo : 445 Mo
Memoire utilisee par MATLAB en exécutant la fonction test : 495 Mo
Memoire utilisee par MATLAB en modifiant la fonction test2 : 545 Mo

Il existe donc bien un tableau "temporaire" X(1:2:end)

Donc si tu ne modifies pas le tableau, mieux vaut le passer en entier.

• Memory Management for Functions and Variables par Loren Shure
• MATLAB Documentation - Memory Allocation

[Aleph69]

Bonjour,

merci beaucoup pour ta réponse et les codes qui vont me permettre de vérifier ce qui se passe en mémoire. Ca répond complètement à ma question donc je passe en résolu.

Encore merci à vous deux!