Discussion :

[totoc1001]

Bonjour a tous,

Dans le sujet "Cercle pour image processing" Tug83 m'a donné un truc pour améliorer le temps d'éxécution des script, celui-ci consist a préallouer de la mémoire en déclarant une matrice au lieu de la remplir et de la faire grandir au fur et a mesure.
Connaitriez vous d'autres astuces commes celle-la permettant de diminuer le temps d'éxécution du script?

Merci
Thomas

[tug83]

pourquoi préallouer:
http://www.mathworks.fr/support/solu...lution=1-18150
la note 1109 sur la vectorisation:
http://www.mathworks.fr/support/tech...1100/1109.html

et la note 1106 pour la mémoire:
http://www.mathworks.fr/support/tech...1100/1106.html

[salseropom]

Bonjour a tous,

Dans le sujet "Cercle pour image processing" Tug83 m'a donné un truc pour améliorer le temps d'éxécution des script, celui-ci consist a préallouer de la mémoire en déclarant une matrice au lieu de la remplir et de la faire grandir au fur et a mesure.
Connaitriez vous d'autres astuces commes celle-la permettant de diminuer le temps d'éxécution du script?

Merci
Thomas

Je ne sais pas si je vais vraiment répondre à ta question mais Matlab c'est lent. Point final. Si tu cherches de la vitesse et un prgm qui utilises moins de mémoire, écrit-le en C ou en Fortran.
Je pense que Matlab est bien pour avoir une idée rapide de la solution sans avoir de pb de pointeurs, de structure, de fuite de mémoire etc...

Pour ma part, suivant mes prgm, 1 seconde de calcul en C réprésente 18 à 22 secondes de calcul en Matlab. Pour moi, il n'y a pas photo. Le dernier exemple que j'ai en date est un prgm où je devais calculer n*2^n nombres suivant un certain algo. Avec Matlab, n = 14 ne passait pas et avec n = 13 il fallait 30 bonnes secondes. En C, n = 20 se faisait en 3 secondes.

Ceci dit, les liens de tug83 sont très intéressant.

[tug83]

j'aurais bien aimé voir ton algo parce que cet écart m'étonne surtout que MATLAB ce n'est que du langage C interprété

[salseropom]

j'aurais bien aimé voir ton algo parce que cet écart m'étonne surtout que MATLAB ce n'est que du langage C interprété

c'est la raison pour laquelle MATLAB est très lent lors de l'exécution. Le C ou Fortran sont des langages compilés ! Voici un exemple de programme qui illustre la lenteur de MATLAB : le produit matriciel. Dans l'exemple suivant, je calcule tout simplement m^2 (où m est une matrice) (je ne peux pas te donner l'algo avec les n*2^n nombres car ce code ne m'appartient pas).

Voici le code en MATLAB :

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
 
clear all
format long
 
n=500;
m=zeros(n);
 
for i=0:n-1
  for j=0:n-1
    m(i+1,j+1)=i+j;
  end
end
 
eltime=0;
 
N=10;
for i=1:N
  start=cputime;
  m^2;
  eltime=eltime+cputime-start;
end
 
eltime/N

voici le code en C

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
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
 
#include<stdio.h>
#include<stdlib.h>
#include<time.h>
 
#define MEMERROR fprintf (stderr,"%s %d : Allocation Memory Error\n", __FILE__, __LINE__)
 
typedef struct
{
    unsigned int nl; /* row number     */
    unsigned int nc; /* columns number */
    double ** data;
} Matrix;
 
Matrix * CreateMatrix(unsigned int nl_,unsigned int nc_,double val)
{
    Matrix * m=malloc(sizeof(*m));
    if(m==NULL)
    {
      MEMERROR;
      exit(EXIT_FAILURE);
    }
 
    if(nl_==0)
      if(nc_!=0)
      {
        fprintf (stderr,"%s %d : Error : nc_ must be equal to 0\n",__FILE__,__LINE__);
	exit(EXIT_FAILURE);	
      }
 
    if(nc_==0)
      if(nl_!=0)
      {
        fprintf (stderr,"%s %d : Error : nl_ must be equal to 0\n",__FILE__,__LINE__);
	exit(EXIT_FAILURE);	
      }
 
    if(nl_==0)
    {
	m->nl=0;
	m->nc=0;
	m->data=NULL;
    }
    else
    {
	m->nl=nl_;
	m->nc=nc_;
	m->data=malloc(nl_*sizeof(double *));
	if(m->data==NULL)
        {
          MEMERROR;
          exit(EXIT_FAILURE);
        }
 
	unsigned int i,j;
	for(i=0;i<nl_;i++)
	{
	  m->data[i]=malloc(nc_*sizeof(double));
	  if(m->data[i]==NULL)
          {
            MEMERROR;
            exit(EXIT_FAILURE);
          }
	  for(j=0;j<nc_;j++) m->data[i][j]=val;
	}
 
    }
 
    return m;
}
 
void DestroyMatrix(Matrix ** m)
{
    (*m)->nc=0;
    (*m)->nl=0;
 
    unsigned int i;
    for(i=0;i<(*m)->nl;i++)
    {
	if((*m)->data[i]!=NULL)
	{
	  free((*m)->data[i]);
	  (*m)->data[i]=NULL;
	}
    }
    free((*m)->data); (*m)->data=NULL;
    free(*m); *m=NULL;
}
 
int main()
{
  unsigned int i,j,k,r;
  const unsigned int n=500;
 
  time_t start,end;
 
  Matrix * m=CreateMatrix(n,n,0.);
 
  for(i=0;i<n;++i)
    for(j=0;j<n;++j) m->data[i][j]=i+j;
 
  /* calcul de m*m */
 
  double eltime=0.;
 
  unsigned int N=10;
 
  for(r=0;r<N;++r)
  {
 
  time(&start);
 
  double s;
  for(i=0;i<n;++i)
  {
    for(j=0;j<n;++j)
    {
      s=0.;
      for(k=0;k<n;++k) s+=m->data[i][k]*m->data[k][j];
    }
  }
 
  time(&end);
 
  //printf("%10.10le\n",difftime(end,start));
 
  eltime+=difftime(end,start);
 
  }
 
  printf("eltime = %10.10le\n",eltime/N);
 
  DestroyMatrix(&m);
 
  return EXIT_SUCCESS;

et voici les résulats (tests effectués sur 10 itérations, comme le montre le prgm).

Code :

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

1
2
3
4
5
 
taille de la matrice     temps en C (s)      temps en MATLAB (s)
500*500                       0.073                              0.128
2000*2000                     4.67                              6.72
4000*4000                     36.07                                  52.74

je crois que ces chiffres parlent d'eux-mêmes. Dans mon post précédent, j'avais dit que matlab était très bien pour avoir un résultat très rapide. Il n'y a qu'à voir le nombre de lignes de ces deux programmes...

Un autre avantage du C par rapport à Matlab : en C on peut passer un pointeur comme argument de fonction. En Matlab on ne passe que la variable. Donc, si l'on passe une matrice en argument, matlab recopie TOUTE la matrice (soit n^2 coefficients) alors qu'en C, on ne passe que l'adresse mémoire de la matrice (soit 4 octets)

Es-tu convaincu ?

Autre preuve : tous les solveurs sont écrits en C ou en Fortran. Auncun en matlab

[tug83]

Un autre avantage du C par rapport à Matlab : en C on peut passer un pointeur comme argument de fonction. En Matlab on ne passe que la variable. Donc, si l'on passe une matrice en argument, matlab recopie TOUTE la matrice (soit n^2 coefficients) alors qu'en C, on ne passe que l'adresse mémoire de la matrice (soit 4 octets)

Es-tu convaincu ?

MATLAB can do it. Heureusement vu que c'est un logiciel qui est leader mondial dans le traitement matriciel.
Pour t'en convaicre tu liras qu'il y a des fonctions permettant de passer de grosses matrices en pointeur sans les copier dans la mémoire:

Code :

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

web([docroot,'/techdoc/matlab_external/f42650.html'])

Tu pourras lire:

You want to modify the data in the input arguments.

You are passing large amounts of data, and you don't want MATLAB to make copies of the data.

The library is going to store and use the pointer for a period of time so it is better to give the M-code control over the lifetime of the pointer object.

In the cases above, you should use libpointer to construct a pointer object of a specified type (for structures use libstruct)

Je vais jeter un oeil sur le code

[salseropom]

ah, super !
tu m'apprends de bonnes choses là.
merci.

[totoc1001]

Bonsoir,

Ca a l'air super cette méthode.
J'ai essayé de lire la doc, mais par contre la je suis vraiment paumé.

Si j'ai bien compris au lieu de passer en paramètre la matrice, on va simplement fournir "un pointeur" sur cette adresse, c'est bien cela;

J'aurais beson d'aide pour bien comprendre comment cela fonctionne:

j'ai écris 4lignes de code, une fonction qui en appelle une autre avec un passe de matrice en paramètre et la seconde matrice retourne une seconde matrice.

Pourriez-vous m'expliquer comment modifier mon code pour ne passer que le pseudo pointer au lieu de la matrice elle même?

MErci beaucoup.

Voici mon code:

Code :

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

1
2
3
4
5
 
function [Result]=Main
    Array=rand(5,5);
    Result=Second(Array);
end

Code :

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

1
2
3
4
 
function [MultArray]=Second(Array)
    MultArray=Array.*10;
end

Merci encore
Thomas
PS: pour ceux que ce interesse, voici le lien de la doc:
http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_external/index.html?/access/helpdesk/help/techdoc/matlab_external/f42650.html&http://www.google.com/search?q='/techdoc/matlab_external/f42650.html'&sourceid=ie7&rls=com.microsoft:en-US&ie=utf8&oe=utf8

[totoc1001]

pourquoi préallouer:
http://www.mathworks.fr/support/solu...lution=1-18150

Bonjour,
J'ai une petite remarque a faire concernant la préallocation. J'ai pu observer que si on initialise une grosse matrice (Matrice=zeros(y,x)) la préallocation va faire améliorer le temps d'éxécution. Mais si on initialise une petite matrice, alors dans ce cas, le temps d'exécution est plus long.
Par exemple, j'ai une matrice A de dimensions [45*511], sur laquelle je vais effectuer et un traitement, et stocker le résultat dans une nouvelle matrice de même dimensions [45*511].
Si je ne déclare pas cette matrice et que je la construit au fur et à mesure, alors le temps d'exécution pour cette fonction est 4.7s.
Maintenant si je déclare cette martrice comme B=zeros(45,511), dans ce cas là, le temps d'exécution passe a 10s.
Est ce que qqelqu'un saurait pourquoi le temps d'exécution s'allonge dans ce cas ou pas?
JE vais encore inverstiguer de mon coté et si je trouve une réponse je tenterais de l'expliquerait

Bye
Thomas