Discussion :

[kzrystof]

Bonjour à tous,

J'ai rencontré à la job une situation étrange que je ne sais pas expliquée: j'ai une séquence dans le programme qui consomme énormément de mémoire. Voici le code incriminé:

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
 
class Program
{
        static void Main(string[] args)
        {
            const int NB_ELEMENTS = 100000;
 
            Vector Y = new Vector(NB_ELEMENTS,1.0);
 
            int i = 1;
            double h = 2.0;
 
            Vector u = new Vector();
 
            do
            {
                u = (0.5 - Y) / h;
 
                i++;
 
            } while (i <= NB_ELEMENTS);
 
            return;
        }
}

Le problème se situe à la ligne suivante:

Code :

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

 u = (0.5 - Y) / h;

où Y et u sont des objets Vecteur. À chaque passage sur cette ligne, le programme consomme 2M de mémoire et elle apparait comme «perdue».

Voici aussi le constructeur de la classe ainsi que l'implémentation de l'opérateur de soustraction.

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
 
public Vector(int nrows, int ncols)
{
        _nbelems = nrows*ncols;
        _nrows = nrows;
        _ncols = ncols; 
        _pElements = new double[nrows,ncols];
}
 
public static Vector operator-(double lhs, Vector rhs)
{
       Vector Res = new Vector(rhs.nrows, rhs.ncols);
       for (int i = 1; i <= rhs.nbelems; i++)
       {
              Res[i] = lhs - rhs[i];
        }
 
        return Res;
}

Ci-joint une capture d'écran de la mémoire vive.

Auriez-vous une idée de ce que j'ai fait de mauvais?

Merci!

Christophe.

[cladsam]

Code :

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

1
2
3
4
5
6
7
  do
            {
                double KSum = double.NaN;
 
                u = (0.5 - Y) / h;
 
            } while (i <= NB_ELEMENTS);

Si tu n'incremente jamais I... sur que ta boucle va durer ^^
En plus , a quoi bon redéclarer KSUm a chaque tour de boucle?

[kzrystof]

L'incrément était un oubli de ma part; je n'ai pas mis le code complet car il n'est pas en cause. Seule l'opération sur les Vecteurs est problèmatique.

[dev01]

Salut .

La gestion de la mémoire est particuliere sous dotnet.

je te conseil cette Q/R et la recherche sur le forum, le sujet à été mainte fois traité.

[Thomas Lebrun]

Question bête: c'est quoi cette classe Vector que tu utilises ? Je n'ai pastrouvé de classe identique dans la MSDN.... ?

[kzrystof]

Salut .

La gestion de la mémoire est particuliere sous dotnet.

je te conseil cette Q/R et la recherche sur le forum, le sujet à été mainte fois traité.

Ce qui me semble étrange, c'est que si je remplace la classe Vecteur (que nous avons développé et qui ne fait qu'encapsuler un tableau de double[,] et utilise un index de base à 1) par un tableau de double [], tout fonctionne à merveille.

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
Vector X = new Vector(500,0.0);
Vector Y = new Vector(100000,0.0);
double KSum = 0.0;
do 
{	
                //u = (X[i]- Y)/ h;
                double[] u = new double[Y.nbelems];
 
                for (int j = 0; j < u.Length; j++)
                {
                    u[j] = (X[i] - Y[j+1]) / h;
                }
 
 
	   //Computes the standard Normal (scalar) probability density function. 
	   //KK = Normal.pdfStdNormal( u );
                Normal.pdfStdNormal( u.Length, u, ref u);
 
                //KSum = KK.sum();
                foreach (double Valeur in u)
                {
                    KSum += Valeur;
                }
 
	    i++;
 
                 KSum = 0.0;
} while (i <= 500);

[abelman]

C'est normal que ce soit gourmand en mémoire.
Analyse de près ton code

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
 
class Program
{
        static void Main(string[] args)
        {
            const int NB_ELEMENTS = 100000;
 
            Vector Y = new Vector(NB_ELEMENTS,1.0); // Création d'un
 vecteur de 100000 elements
 
            int i = 1;
            double h = 2.0;
 
            Vector u = new Vector(); // Création d'un vecteur vide je
 suppose (pas de constructeur posté)
 
            do
            {
                u = (0.5 - Y) / h; // Ici à chaque fois, tu recrée en mémoire
 un nouveau vecteur de 100000 elements (le vecteur Res dans le code de
 l'opérateur.). Et celui que u contient avant l'affectation est perdu. Cette
 opération est faite 100000 fois dans ta boucle.
 
                i++;
 
            } while (i <= NB_ELEMENTS);
 
            return;
        }
}
 
public static Vector operator-(double lhs, Vector rhs)
{
       Vector Res = new Vector(rhs.nrows, rhs.ncols);
       for (int i = 1; i <= rhs.nbelems; i++)
       {
              Res[i] = lhs - rhs[i];
        }
 
        return Res;
}

Avec un tableau de double je pense que ça va plus vite car c'est un tableau de type valeurs alors que les variable Vector sont des références. C'est une des explications.

[davcha]

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
class Program
{
        static void Main(string[] args)
        {
            const int NB_ELEMENTS = 100000;
 
            Vector Y = new Vector(NB_ELEMENTS,1.0);
 
            int i = 1;
            double h = 2.0;
 
            Vector u = new Vector();  // sert à quoi ?
 
            do
            {
                u = (0.5 - Y) / h;   // on instancie plein de vecteurs sûrement
 pour rien.
 
                i++;
 
            } while (i <= NB_ELEMENTS);
 
            return;
        }
}

Code :

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

1
2
3
4
5
6
7
8
9
10
public static Vector operator-(double lhs, Vector rhs)
{
       Vector Res = new Vector(rhs.nrows, rhs.ncols);
       for (int i = 1; i <= rhs.nbelems; i++)
       {
              Res[i] = lhs - rhs[i];
        }
 
        return Res;
}

Faudrait peut-être changer ça.

Au lieu d'instancier un nouveau vecteur à chaque cycle de la boucle, faudrait peut-être faire ce que tu avais, apparemment, initialement l'intention de faire :

Code :

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

1
2
3
4
5
6
7
8
9
Vector u = new Vector();
 
do
{
    Vector.compute(0.5,Y,h,u);
 
    i++;
 
} while (i <= NB_ELEMENTS);

avec Vector.compute(in double, in Vector, in double, out u) une méthode statique de Vector de ce genre là :

Code :

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

1
2
3
4
5
6
7
8
9
 
public static void compute(double lhs, Vector rhs, double h, out Vector u){
    if(u.nbelems != rhs.nbelems)
        throw new ArgumentException("blabla vecteur u pas cool...");
    for (int i = 1; i <= rhs.nbelems; i++)
    {
        u[i] = (lhs - rhs[i]) / h; // ou quelque soit l'opération de division...
    }
}