Discussion :

[AnthoB]

Bonjour à vous,

Je développe un prototype de simulation de circuits électronique. Jusque là tout fonctionnait très bien et j'ai voulu passé sur des circuits plus conséquents, et là matlab ne répond plus!

J'utilise pour cela la Symbolic toolbox, et à un moment donné je dois inverser une matrice (contenants des symboles) de la taille du nombre de nœuds dans le circuit. Et c'est à partir de ce moment que matlab devient très très lent jusqu'à ne plus répondre du tout (je l'ai même laissé tourné plus de 7h, au bout du compte il m'affiche une erreur bizarre..) J'ai aussi écris ma propre fonction d'inversion de matrices pour pouvoir contrôler les problèmes, en essayant de simplifier les équations au fur et à mesure, mais toujours le même problème.

Alors j'ai plusieurs questions :
- Est-ce que vous avez des idées pour améliorer le processus sous matlab?
- Est-ce que je dois passer sur un autre langage plus dédié au calcul formel? Et si oui lequel me conseillez vous? Mathematica? Maple? XCad?
- Et est-ce qu'il existe des passerelles entre Matlab et l'un d'eux, ou je serais obligé de tout réécrire?

Je ne suis peut-être pas très clair dans mes explications, j'ai essayé d'aller au plus court... Mais si vous avez des questions j'y répondrais bien entendu!

[Jean Dumoncel]

Bonjour,

tu peux nous donner le message d'erreur obtenu?

[AnthoB]

Ok, je vais essayer de le reproduire. Je vous poste ça dans quelques heures !
Aussi j'ai remarqué que MATLAB utilisait plus de 2Go de mémoire vive, même après avoir stoppé le calcul et affiché l'erreur...

[Jean Dumoncel]

Aussi j'ai remarqué que MATLAB utilisait plus de 2Go de mémoire vive, même après avoir stoppé le calcul et affiché l'erreur...

Si tes variables sont toujours chargées en mémoire, oui, c'est normal.

[le fab]

de plus matlab ne sait pas nettoyer correctement sa mémoire, donc ce n'est pas surprenant (il m'arrivait souvent de devoir fermer / ré ouvrir matlab pour retrouver de la mémoire ... ca va mieux depuis que je suis en 64 bits)

en ce qui me concerne j’utilise aussi un peu la symbolic math toolbox et j'ai également remarqué une grande lenteur sur des gros problèmes
mais je n'ai pas de solution à te donner
(dans mon cas les matrices que je cherche à obtenir (hessian) ont une forme simple, que je met en évidence via la symbolic toolbox sur un problème petit puis que j'extrapole à la main via des boucles for)

[AnthoB]

Merci pour vos réponses. En effet cela semble logique que la mémoire vive ne soit libérée qu'à partir de la suppression des variables.

Bon j'ai laissé tourner mon programme toute la nuit et finalement je n'ai pas obtenu la même erreur. Je vais vous donner un peu plus de précision.
Voici la matrice que je doit inverser pour mon circuit d'exemple:

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
 
[ 1/Rp1 + 1/Rp2,                     0,                  -1/Rp1,              0,             0,     0,                  0,              0,                  -1/Rp2,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 1, 0]
[             0, Gc_C3 + Gc_Co1 + 1/R4,                 -Gc_Co1,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                        -1/R4,                            0,                                                                            0,                  -Gc_C3,                       0,                                        0, 0, 0]
[        -1/Rp1,               -Gc_Co1, Gc_Cf1 + Gc_Co1 + 1/Rp1,              0,       -Gc_Cf1,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0, Gc_Ck1 + 1/Rk1,             0,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                 -Gc_Cf1,              0, Gc_Cf1 + 1/R1,     0,              -1/R1,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,  1/R3,              -1/R3,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 1]
[             0,                     0,                       0,              0,         -1/R1, -1/R3, 1/R1 + 1/R2 + 1/R3,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0, Gc_Co2 + 1/Ro2,                 -Gc_Co2,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[        -1/Rp2,                     0,                       0,              0,             0,     0,                  0,        -Gc_Co2, Gc_Cf2 + Gc_Co2 + 1/Rp2,              0,                                        -Gc_Cf2,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                       0, Gc_Ck2 + 1/Rk2,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                 -Gc_Cf2,              0, Gc_C5 + Gc_Cf2 + 1/PR1_P_XGain + 1/PR2_P_XGain,                            0,                            0,                                                      - Gc_C5 - 1/PR1_P_XGain,                       0,                       0,                                        0, 0, 0]
[             0,                 -1/R4,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0, Gc_C1 + 1/PR1_P_XBass + 1/R4,                            0,                                                      - Gc_C1 - 1/PR1_P_XBass,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                            0, Gc_C2 + 1/PR2_P_XBass + 1/R5,                                                      - Gc_C2 - 1/PR2_P_XBass,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                       0,              0,                        - Gc_C5 - 1/PR1_P_XGain,      - Gc_C1 - 1/PR1_P_XBass,      - Gc_C2 - 1/PR2_P_XBass, Gc_C1 + Gc_C2 + Gc_C5 + 1/PR1_P_XGain + 1/PR1_P_XBass + 1/PR2_P_XBass + 1/R6,                       0,                       0,                                    -1/R6, 0, 0]
[             0,                -Gc_C3,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0, Gc_C3 + 1/PR2_P_XTreble,                       0,                         -1/PR2_P_XTreble, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0, Gc_C4 + 1/PR1_P_XTreble,                         -1/PR1_P_XTreble, 0, 0]
[             0,                     0,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                        -1/R6,        -1/PR2_P_XTreble,        -1/PR1_P_XTreble, 1/PR1_P_XTreble + 1/PR2_P_XTreble + 1/R6, 0, 0]
[             1,                     0,                       0,              0,             0,     0,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]
[             0,                     0,                       0,              0,             0,     1,                  0,              0,                       0,              0,                                              0,                            0,                            0,                                                                            0,                       0,                       0,                                        0, 0, 0]

Après l'inversion de cette matrice, se passe quelque opérations plutôt simples , mais tout ça à vitesse extrêmement lente. Jusqu'à la récupération du système d'équations sous forme de fonction via matlabFunction, et j'obtient cette erreur :

Code :

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

1
2
3
4
5
6
7
8
9
 
Error using sym/matlabFunction>checkVars (line 153)
Variable names must be valid MATLAB variable names.
 
Error in sym/matlabFunction (line 104)
vars = checkVars(funvars,opts);
 
Error in Matrix_M_auto/CreateMatlabFunctions (line 887)
                Circuit.A = matlabFunction(MNA.A);

Et ma mémoire vive était prise entièrement par matlab... Du coup je me demande : Si j'en rajoute sur mon ordinateur, est-ce qu'il y a plus de chance pour que le calcul se fasse? Autre chose, Matlab utilise un seul de mes deux processeurs, est-ce qu'il y a une possibilité pour utiliser le second pour améliorer la vitesse de calcul?

[le fab]

Et ma mémoire vive était prise entièrement par matlab... Du coup je me demande : Si j'en rajoute sur mon ordinateur, est-ce qu'il y a plus de chance pour que le calcul se fasse?

peut etre
pour répondre à la question, peux tu faire tourner ton programme sur un problème plus simple (matrices de plus petites tailles, moins de variable)

Autre chose, Matlab utilise un seul de mes deux processeurs, est-ce qu'il y a une possibilité pour utiliser le second pour améliorer la vitesse de calcul?

la parallel computing toolbox permet ce genre de choses, encore faut il que ton programme soit facilement découpable

[le fab]

Code :

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

1
2
3
4
5
6
7
8
9
Error using sym/matlabFunction>checkVars (line 153)
Variable names must be valid MATLAB variable names.

Error in sym/matlabFunction (line 104)
vars = checkVars(funvars,opts);

Error in Matrix_M_auto/CreateMatlabFunctions (line 887)
                Circuit.A = matlabFunction(MNA.A);

tu pourrais ajouter un dbstop if error avant l'exécution de ton programme pour voir quelle variable pose problème

[Jerome Briot]

- Est-ce que je dois passer sur un autre langage plus dédié au calcul formel?

Si on peut dire, MATLAB ne fait pas le calcul formel lui-même.
Après avoir longtemps utilisé le moteur de Maple, il utilise maintenant celui de MuPAD

Comme mentionné dans la FAQ , en "équivalent" gratuit, tu as SAGE (écrit en Python)

Et ma mémoire vive était prise entièrement par matlab... Du coup je me demande : Si j'en rajoute sur mon ordinateur, est-ce qu'il y a plus de chance pour que le calcul se fasse? Autre chose, Matlab utilise un seul de mes deux processeurs, est-ce qu'il y a une possibilité pour utiliser le second pour améliorer la vitesse de calcul?

Quelle version de MATLAB utilises-tu ?
Sur quel système d'exploitation travailles-tu ?
En 32 ou 64 bits ?

[AnthoB]

J'utilise un Matlab R2011b 64bits, et mon OS est un Windows 7 64bits.
Proc. Dual Core E8400 à 3Ghz et 4Go de mémoire vive.

Donc tu penses que si je réécrit mon programme sous Sage cela résoudra mon problème?

[Jerome Briot]

As-tu utilisé le profiler de MATLAB pour identifier les parties de ton code les plus gourmandes en temps ?

Code :

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

doc profile

N'aurais-tu pas une machine plus puissante (surtout avec plus de RAM) à disposition pour faire des tests ?

4Go de mémoire vive.

Vu le prix du Go de RAM aujourd'hui, tu pourrais la doubler sans trop de problème (voir la capacité de la carte mère de ta machine)

Donc tu penses que si je réécrit mon programme sous Sage cela résoudra mon problème?

Je ne fais pas de calcul formel, je ne pux donc pas te répondre précisément.

Mais comme SAGE est gratuit, ça ne coute rien d'essayer (à part le temps d'adaptation à sa syntaxe).

[AnthoB]

As-tu utilisé le profiler de MATLAB pour identifier les parties de ton code les plus gourmandes en temps ?

Non je ne connaissais pas, je vais essayer ça!

N'aurais-tu pas une machine plus puissante (surtout avec plus de RAM) à disposition pour faire des tests ?

Malheureusement non! Je pense que je vais aller en acheter dans la semaine, j'ai encore 2 slots de libre sur ma carte mère.

Sinon je vais essayer de passer sur Sage (je connais un peu le Python donc cela devrait se faire sans trop de soucis).
Après il me restera à étudier des méthodes de simulation plus récentes... (Celle que j'utilise date de 2010, donc il y a encore peu de recul sur la méthode). Mais il va falloir que je me replonge dans la théorie profonde, et comme vous pouvez le constater, je suis loin d'être un génie

En attendant je vais faire un tour, parce que là mes circuits surchauffent!
Merci pour vos conseils, je reviendrais par là pour vous dire si j'ai résolu le problème!