Fuite mémoire fortran?

**palex** · 02/04/2014, 16h28

bonjour à tous,

je solicite votre aide concernant un programme fortran sur lequel j'interviens dans le cadre de mon travail. Perso je code en Java et C.

l'application est assez vieille et à l'époque il y a eu du dev en fortran pour realiser des calculs, qui lui meme est appelé via du C et le C nous l'appelons via JNI pour la partie java.

et il se trouve que le code en question provoque une fuite mémoire assez importante mais n'y connaissant rien du tout en fortran, j'aimerais si quelqu un a un peu de temps de regarde le code suivant afin de me donner une piste sur une éventuelle fuite mémoire.

merci beaucoup!

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
136
137
 
 
c	-----------------------------------------------------------------
	subroutine modlin_OM(pmt,abaque,don,cond,res,flag)
c	-----------------------------------------------------------------
 
      !DEC$ ATTRIBUTES ALIAS : "modlin_OM" :: modlin_OM
      !DEC$ ATTRIBUTES DLLEXPORT :: modlin_OM
 
c	MODELE modlin
c
c	MARCO-POLO V2 - Outils Métiers Eau
c	-----------------------------------------------------------------
c	Programmation DLL	2005 (JG)
c	-----------------------------------------------------------------
 
c	-----------------------------------------------------------------
c	DIMENSIONNEMENT TABLEAUX E/S
c	-----------------------------------------------------------------
 
	implicit none
	integer ndon, nres
	parameter (ndon=4, nres=2)
 
	real pmt(*),abaque(3,*),don(ndon,*),cond(*),res(nres,*)
	integer flag
 
c	-----------------------------------------------------------------
c	DECLARATIONS VARIABLES LOCALES
c	-----------------------------------------------------------------
 
      INTEGER lmax,nmax
	PARAMETER (lmax=100,nmax=30000)
 
      INTEGER i,j,k,l
 
      real db1(nmax),db2(nmax),db3(nmax)
      real dbs(nmax),s(nmax)
	real splus(nmax),Biais
	real FT(3,lmax)
 
	integer n1,n2,n3,n_propa
 
      integer nech,n,n0
 
	INTEGER NTroncon
 
	REAL :: NODATA = -9999.
 
c	-----------------------------------------------------------------
c	AFFECTATION DES PARAMETRES ET DES DONNEES
c	-----------------------------------------------------------------
 
      flag = 0
	n    = INT(cond(1))
	nech = INT(cond(2))
 
      NTroncon = INT(pmt(1))
	n1  = INT(pmt(2))
	n2  = INT(pmt(3))
	n3  = INT(pmt(4))
 
	IF ((n.GT.nmax)) THEN
	  flag = 1 ! Erreur n°1 : Nombre de valeurs trop importante
	  RETURN
	ENDIF
 
	n_propa = max(n1,n2,n3)
	IF ((n_propa.GT.lmax)) THEN
	  flag = 2 ! Erreur n°2 : Fonctions de transfert trop longues
	  RETURN
	ENDIF
 
	! Series Chronologiques
	DO i = 1,n
	  dbs(i) = don(1,i)
	  db1(i) = don(2,i)
	  db2(i) = don(3,i)
	  db3(i) = don(4,i)
	ENDDO
 
	! Fonctions de transfert
	FT(1:3,1:n_propa) = abaque(1:3,1:n_propa)
 
c	-----------------------------------------------------------------
c	Propagation
c	-----------------------------------------------------------------
 
      s(1:n) = 0.
 
      DO i = 1,n
        DO j = 1,n_propa
          k = max(i-j+1,1)
          IF (n1>0) s(i) = s(i) + FT(1,j)*db1(k)
          IF (n2>0) s(i) = s(i) + FT(2,j)*db2(k)
          IF (n3>0) s(i) = s(i) + FT(3,j)*db3(k)
        ENDDO
      ENDDO 
 
c	-----------------------------------------------------------------
c	Recalage sur le dernier observe
c	-----------------------------------------------------------------
 
	! recherche du dernier débit non manquant
	n0 = 0
	DO i = n-nech,1,-1
	  IF(don(1,i).NE.NODATA) THEN
	    n0 = i
	    EXIT
	  ENDIF
	ENDDO
	IF (n0.EQ.0) THEN
	  flag = 3 ! Erreur n°3 : aucun débit observé pour recalage
	  RETURN
	ENDIF
	nech = n-n0
 
	splus(1:n0-1) = NODATA
	splus(n0) = dbs(n0)
	Biais = dbs(n0)-s(n0)
 
	DO j = 1,nech
	  splus(n0+j) = s(n0+j) + Biais
	ENDDO
 
c	-----------------------------------------------------------------
c	Stockage des resultats
c	-----------------------------------------------------------------
 
      s(1:n_propa) = NODATA
 
      DO i = 1,n
        res(1,i) = s(i)
	  res(2,i) = splus(i)
      ENDDO
 
      END

**hector2** · 03/04/2014, 18h52

bonjour,
je ne vois pas d' allocation mémoire dans le code fortran, donc j'aurais tendance à penser que la fuite mémoire vient soit de la couche C, soit de la couche JNI...

**palex** · 09/04/2014, 16h50

bonjour,

merci pour votre réponse,

en effet j'ai pu constater qu il n'y avait pas d'allocate, mais est ce que les paramètres passé sous forme de pointeur ou les tableau dimensionné à taille fixe voir meme cette ligne :

Code :

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

real pmt(*),abaque(3,*),don(ndon,*),cond(*),res(nres,*)

pourrai générer des choses en mémoire qui ne serai jamais libéré?

car j'ai réalisé un test en mettant en commentaire l'appel au fortran, mais le reste du programme est identique et la je ne constate pas de fuite mémoire.

voici le code C en question

Code c :

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
 
#include <stdio.h>
#include <stdlib.h>
#include "CModlin.h" 
#include "../trace.h" 
#include "../commun.h" 
 
// FORTRAN routines have to be prototyped as extern, and parameters are
// passed by reference.  Note also that for g77 the function name in C by
// default must be prefixed by a "_".
#ifndef unix
__MINGW_IMPORT void modlin_OM(float pmt[], float abaque[][], float don[][], float cond[], float res[][], int flag[]) ;
#else
extern void modlin_om_(float * pmt, float * abaque, float * don, float * cond, float * res, int * flag) ;
#endif
/*
 * Class:     fr_edf_mpv2_serveurcalcul_castor_transverse_traitement_outilmetier_TrtModlin
 * Method:    modlin_OM
 * Signature: ([F[[F[[F[F[[D[I)I
 */
JNIEXPORT jint JNICALL Java_fr_edf_mpv2_serveurcalcul_castor_transverse_traitement_outilmetier_TrtModlin_modlin_1OM
  (JNIEnv * env, jobject obj, 
	 jfloatArray pmtPar, 
	 jobjectArray abaquePar, jobjectArray donPar, jfloatArray condPar, jobjectArray resPar, jintArray flagPar)
{
   float ** don0 = NULL ; // Pour pouvoir désallouer les élèments Java
   float ** abaque0 = NULL ; // Pour pouvoir désallouer les élèments Java
	 int err = 0 ;
	 jfloat *pmt;
	 jfloat *cond;
	 jfloat * abaque; //[SIZE_DON_2][SIZE_DON_1] ;  
	 jfloat * don; //[SIZE_DON_2][SIZE_DON_1] ;  
	 jfloat * res, * resSvg ; //[SIZE_RES_2][SIZE_RES_1] ;  // Resultats
	 int * flag ; //[SIZE_FLAG] ;   // Retour Erreur
	 int iFlag=0 ;
 
	 SetLogFileName("Modlin.log") ;
	 //
	 // Init paramètre : pmt
	 //
	 if((err = GetTableauFloat("pmt", env, pmtPar, & pmt))== 0)
	 {
		 //
		 // Init paramètre : abaque
		 //
		 if((err = GetMatriceFloat("abaque", env, abaquePar, & abaque0, & abaque))== 0)
		 {
			 //
			 // Init paramètre : cond
			 //
			 if((err = GetTableauFloat("cond", env, condPar, & cond)) == 0)
			 {
				 //
				 // Init parametre : don
				 //
				 if((err = GetMatriceFloat("don", env, donPar, & don0, & don)) == 0)
				 {
					 //
					 // Allocation du tableau résultat
					 //
					 ZTrace("Allocation res") ;
					 if((err = AllocationMatriceFloat("res", env, resPar, & res)) == 0)
					 {
						 //
						 // Allocation du tableau flag
						 //
						 if((err = AllocationTableauInt("flag", env, flagPar, & flag)) == 0)
						 {
							 resSvg = res ;
							 ZTrace("flag = %x res = %x", flag, res) ;
							 //
							 // Appel routine fortran
							 //
							 ZTrace("Appel modlin_OM") ;
							 #ifndef unix
							   modlin_OM(pmt, abaque, don, cond, res, & iFlag) ;
							 #else
							   modlin_om_(pmt, abaque, don, cond, res, & iFlag) ;
						        #endif
							 ZTrace("Retour modlin_OM") ;
 
							 ZTrace("flag = %x res = %x", flag, res) ;
							 //
							 // Traitement paramètre de retour : flag
							 //
							 flag[0] = iFlag ;
							 if((err = TransfertTableauInt("flag", env, flagPar, flag)) == 0)
							 {
								 res = resSvg ;
								 //
								 // Traitement paramètre de retour : res
								 //
								 if((err = TransfertMatriceFloat("res", env, resPar, res)) == 0)
								 {
								 }
							 }
							 ZTrace("Libère flag") ;
							 free(flag) ;
						 }
						 ZTrace("Libère res") ;
						 free(res) ;
					 }
					 ZTrace("Libère don") ;
					 free(don) ;
				   if(don0)
             FreeMatriceFloat(env, donPar, don0) ;
				 }
			   (*env)->ReleaseFloatArrayElements(env, condPar, cond, JNI_ABORT) ;
			 }
			 ZTrace("Libère abaque") ;
			 free(abaque);
			 if(abaque0)
         FreeMatriceFloat(env, abaquePar, abaque0) ;
		 }
		 (*env)->ReleaseFloatArrayElements(env, pmtPar, pmt, JNI_ABORT) ;
	 }
	 return err ;
}

l'appel au code Fortran est ici :

Code c :

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

1
2
3
4
5
6
 
		#ifndef unix
			modlin_OM(pmt, abaque, don, cond, res, & iFlag) ;
		#else
			modlin_om_(pmt, abaque, don, cond, res, & iFlag) ;
		#endif

j'ai donc réalisé un test en le mettant en commentaire et je n'ai constaté aucune fuite mémoire, ce qui indique que les objets alloué via le C sont bien libéré par la suite.

si jamais vous avez une autre idée je suis preneur.

merci

Fuite mémoire fortran?

Fortran

Vue hybride

Discussions similaires

Partager

Partager