problème d'écrasement mémoire

Version imprimable

Bonjour, voici le code qui me cause un soucis (je m'excuse d'avance mais la balise CODE ne fonctionne pas sur mon PC....) :
Code:

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 #define TAILLE_MAX 1024 #define DECALAGE 10 int ma_fun(donnees * data) { double x[TAILLE_MAX], y[TAILLE_MAX], * x_temp, * y_temp, a, b; int i; for (i=DECALAGE; i<data->compteur_fluage1; i++) { x[i-DECALAGE] = data->date_fluage1[i] - data->date_fluage1[0] ; x[i-DECALAGE] /= 1000. ; y[i-DECALAGE] = data->deflaser_fluage1[i] ; } nb_points = data->compteur_fluage1-DECALAGE; /* ici nb_points == 39 */ x_temp = calloc(nb_points, sizeof(*x_temp)); y_temp = calloc(nb_points, sizeof(*y_temp)); if(x_temp == NULL || y_temp == NULL) { FREE(x_temp); FREE(y_temp); return ERR_ALLOC; } for (i=0; i<nb_points; i++) { x_temp[i] = x[i]; y_temp[i] = y[i]; } F_D(x_temp,y_temp,&a,&b); /* suite du code */ }
F_D est une fonction fortran externe située dans une librairie développée en interne. C'est une fonction double précision (la version simple précision est la fonction F)

Je travaille avec Visual C++ 6.0. En mode Debug, je n'ai aucun soucis. En revanche, en mode Release, j'ai un écrasement mémoire. Après le passage dans la fonction F_D, les 18 premières composantes du vecteur y (j'ai bien dit y et non y_temp) sont modifiées. Pourtant cette variable n'est pas un argument de la fonction F_D. Si j'utilise la version simple précision (F et non plus F_D) le problème disparaît ... mais ça plante plus tard dans mon code car j'obtiens ensuite une matrice non inversible.

Pouvez-vous s'il vous plait me donner des pistes de recherche pour déterminer l'origine de cet écrasement mémoire ?

Un collègue m'a parlé de purify.

Meric d'avance, et excusez-moi du fait que la balise CODE ne marche pas sur mon PC.

31/07/2008, 09h06
ram-0000
Citation:

Envoyé par salseropom

je m'excuse d'avance mais la balise CODE ne fonctionne pas sur mon PC....) :

Pardon :question:

Sinon, purify est un logiciel qui va effectivement te permettre de détecter les écrasements dans ton programme. Ceci dit, cela ne corrigera pas le problème et purify ne pourra rien pour toi.

Je pense que la bonne approche est de regarder ce qui se passe dans la fonction F_D().

Juste quelques questions au passage lors de l'appel F_D(x_temp,y_temp,&a,&b);
- comment la fonction F_D connait le nombre de points et donc la taille de x_temp et y_temp alloués de manière dynamique.
- A quoi servent les variables a et b, elles ne semblent pas initialisées lors de l'appel.
31/07/2008, 09h06
Melem

C'est justement cette fonction F_D qui ne m'inspire pas confiance. Déjà, comment se fait-il qu'une fonction qui traite un tableau dont l'adresse est passée en paramètre ne demande pas la taille de ce tableau, on ne peut peut-être pas passer n'importe quel tableau à cette fonction, seulement des tableaux de N éléments (je ne sais pas la valeur de N). Si tu passe un tableau de taille < N, ce sera ta fête ... Il faut donc que tu nous explique ce que fait exactement cette fonction (quelles sont les entrées, que fait la fonction, quelles sont les sorties) avec un exemple qui marche.

Citation:

Meric d'avance, et excusez-moi du fait que la balise CODE ne marche pas sur mon PC.

Incroyable. Mais dans l'avenir, tu peux toujours les placer manuellement : (CODE)...(/CODE), en remplaçant les () par des [].
31/07/2008, 09h10
yan

Salut,
peut tu mettre la signature de F_D?

1- soit double ne correspond pas à ce que demande le code fortran,
2-soit ton tableau est trop petit puisque cette fonction va écrire ailleurs.

Je parie pour la deuxième, car tu ne donne pas la taille de tes tableaux à F_D.

Sinon, pourquoi calloc???
[edit] grillé

Bonjour,
voici le code original :

Code:

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
 
#include "header.h"
#include "global.h"
#include "publicmacros.h"
#include "memory.h"
 
int extra(int numFic, donnees *data, 
		  Struc_Mat *temps_fluage, Struc_Mat *def_mes_fluage, Struc_Mat *def_mod_fluage, Struc_Param_Modele *coef_V) 
{
 
/*
* Declarations
*/
 
    double x[TAILLE_MAX], y[TAILLE_MAX], W[TAILLE_MAX], Z[TAILLE_MAX],
           V[2], res[20], pente, ordonnee ; 
	double E[2], A[4];
    int M, MAXFN, i, nb_points, ier;
	double *x_temp=NULL, *y_temp=NULL;
 
/*
* Obtention des elements necessaires a l'ajustement
*/
 
    for (i=DECALAGE; i<data->compteur_fluage1; i++) 
	{
        x[i-DECALAGE] =  data->date_fluage1[i] - data->date_fluage1[0] ;
        x[i-DECALAGE] /= 1000. ;
        y[i-DECALAGE] =  data->deflaser_fluage1[i] ;
    }
 
/* Obtention des estimations initiales de a et b */
 
    /*nb_points = 10 ;*/
	nb_points = data->compteur_fluage1-DECALAGE;
	x_temp    = calloc(nb_points, sizeof(double));
	y_temp    = calloc(nb_points, sizeof(double));
 
	if(x_temp == NULL || y_temp == NULL)
	{
	  FREE(x_temp); FREE(y_temp);
	  return ERR_ALLOC;
	}
 
 
	for (i=0; i<nb_points; i++)
	{
		x_temp[i] = x[i];
		y_temp[i] = y[i];
	}
 
    F_D(x_temp, y_temp, &nb_points, &pente, &ordonnee, res, &ier);

31/07/2008, 09h16
salseropom

Citation:

Envoyé par Melem

Incroyable. Mais dans l'avenir, tu peux toujours les placer manuellement : (CODE)...(/CODE), en remplaçant les () par des [].

OK merci
31/07/2008, 09h19
ram-0000

Citation:

Envoyé par salseropom

voici le code original

Je pense que c'est plutot le code de F_D() qui nous intéresse

Re, voici le code de la fonction F_D

Code:

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
 
subroutine f_d ( xm   , ym  , nm  ,  a  ,  b ,
     &                         res  , ier )
      implicit double precision (a-h,o-z)
      dimension xm(1),ym(1),res(1)
 
      do i = 1 , nm
         res(i) = 0.d0
      end do
 
      if ( nm.lt.2 ) then
         ier = -1
         a   = 1.d38
         b   = a
         return
      end if
 
      xmin = xm(1)
      ymin = ym(1)
      xmax = xm(1)
      ymax = ym(1)
      do i = 2 , nm
         if (xmax.lt.xm(i)) xmax = xm(i)
         if (ymax.lt.ym(i)) ymax = ym(i)
         if (xmin.gt.xm(i)) xmin = xm(i)
         if (ymin.gt.ym(i)) ymin = ym(i)
      end do
      valnx = (xmax-xmin) / 2.d0
      valny = (ymax-ymin) / 2.d0
 
      if ( dabs(valnx).lt.1.d-10 ) then
         ier = -3
         a   = 1.d38
         b   = a
         return
      end if
 
      if ( dabs(valny).lt.1.d-10 ) then
         ier = 0
         a   = 0.d0
         b   = 0.d0
         return
      end if
 
      sx  = 0.d0
      sy  = 0.d0
      sxy = 0.d0
      sx2 = 0.d0
 
      do i = 1 , nm
	 dble_i   = dble(i)
         xnor = ( xm(i) - valnx ) / valnx
         ynor = ( ym(i) - valny ) / valny
         sx   = sx  + ( xnor      - sx )  / dble_i
         sy   = sy  + ( ynor      - sy )  / dble_i
         sxy  = sxy + ( xnor*ynor - sxy ) / dble_i
         sx2  = sx2 + ( xnor*xnor - sx2 ) / dble_i
      end do
 
      det = sx2 - sx * sx
 
      if ( dabs(det).lt.1.d-10 ) then
         ier = -2
         a   = 1.d38
         b   = a
         return
      else
         ier = 0
         dta = sxy - sy * sx
         dtb = sy * sx2 - sx * sxy
         anorm = dta / det
         bnorm = dtb / det
      end if
 
      rap = valny / valnx
      a   = anorm * rap
      b   = ( bnorm - anorm + 1.d0 )*valny
 
      do i = 1 , nm
         ycal =  a * xm(i) + b
         res(i) = ycal - ym(i)
      end do
 
      return
      end

31/07/2008, 09h50
yan
Code:

F_D(x_temp, y_temp, &nb_points, &pente, &ordonnee, res, &ier);
Code:

1 2 3 4 subroutine f_d ( xm , ym , nm , a , b , & res , ier ) implicit double precision (a-h,o-z) dimension xm(1),ym(1),res(1)
pourquoi &nb_points,&pente, &ordonnee,&ier?
pourquoi res est limité à 20?

Je ne suis pas un pro du fortran mais j'ai un doute si le nombre de points est plus grand que 20.
Code:

1 2 3 4 5 6 7 8 9 10 subroutine f_d ( xm , ym , nm , a , b , & res , ier ) implicit double precision (a-h,o-z) dimension xm(1),ym(1),res(1) ... do i = 1 , nm res(i) = 0.d0 end do ...
C'est une boucle qui initialise le tableau res pour tous les indices de 1 à nm. J'ai bon ?
Code:

1 2 3 4 double x[TAILLE_MAX], y[TAILLE_MAX], W[TAILLE_MAX], Z[TAILLE_MAX], V[2], res[20], pente, ordonnee ; ... F_D(x_temp, y_temp, &nb_points, &pente, &ordonnee, res, &ier); ...
le tableau res passé en paramètre est un tableau de 20 double

31/07/2008, 09h57
salseropom

Salut

merci beaucoup !!
effectivement, en mettant res[100] et non plus res[20] ca marche

et comme nb_points == 39, ceci explique que les 19 1e composantes de mon vecteur y aient été modifiées

Merci beaucoup !
31/07/2008, 12h06
ram-0000

Mon avis sur ce que tu viens de faire :

Cela s'appelle une rustine sur une jambe de bois. Normallement, ce bug va te repèter au visage et si cela se passe bien, cela sera au pire moment :P

en fait voilà la version modifiée (et qui marche...)

Code:

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
 
#include "header.h"
#include "global.h"
#include "publicmacros.h"
#include "memory.h"
 
int extra(int numFic, donnees *data, 
		  Struc_Mat *temps_fluage, Struc_Mat *def_mes_fluage, Struc_Mat *def_mod_fluage, Struc_Param_Modele *coef_V) 
 
{
 
/*
* Declarations
*/
 
    double x[TAILLE_MAX], y[TAILLE_MAX], W[TAILLE_MAX], Z[TAILLE_MAX],
           V[2], pente, ordonnee ; 
	double E[2], A[4];
    int M, MAXFN, i, nb_points, ier;
	double *x_temp=NULL, *y_temp=NULL, *res=NULL;
 
/*
* Obtention des elements necessaires a l'ajustement
*/
 
    for (i=DECALAGE; i<data->compteur_fluage1; i++) 
	{
        x[i-DECALAGE] =  data->date_fluage1[i] - data->date_fluage1[0] ;
        x[i-DECALAGE] /= 1000. ;
        y[i-DECALAGE] =  data->deflaser_fluage1[i] ;
    }
 
/* Obtention des estimations initiales de a et b */
 
	nb_points = data->compteur_fluage1-DECALAGE;
	x_temp    = calloc(nb_points, sizeof(double));
	y_temp    = calloc(nb_points, sizeof(double));
	res       = calloc(nb_points, sizeof(double));
 
	if(x_temp == NULL || y_temp == NULL || res == NULL)
	{
	  FREE(x_temp); FREE(y_temp); FREE(res);
	  return ERR_ALLOC;
	}
 
 
	for (i=0; i<nb_points; i++)
	{
		x_temp[i] = x[i];
		y_temp[i] = y[i];
	}
 
    F_D(x_temp, y_temp, &nb_points, &pente, &ordonnee, res, &ier);

ainsi, x_temp, y_temp et res ont toujours la même dimension.

Est-ce correct ?

31/07/2008, 13h52
yan

Citation:

Envoyé par salseropom

ainsi, x_temp, y_temp et res ont toujours la même dimension.
Est-ce correct ?

Beaucoup plus oui.
Par contre je suis étonné que tu doit passer des pointeur pour les variables nb_points, pente, ordonnee, et ier...
31/07/2008, 14h52
Médinoc

FORTRAN ne fait-il pas du passage par référence ?

Edit: Apparemment, si, plus ou moins.

Donc, ça explique pourquoi on passe les adresses à la fonction.