Erreur : Program received signal SIGSEGV: Segmentation fault - invalid memory reference.

Version imprimable

1 pièce(s) jointe(s)

Bonjour à tous,

J'essaie de coder Runge Kutta Merson sur fortran, malheureusement, ce message d'erreur apparait : "Program received signal SIGSEGV: Segmentation fault - invalid memory reference.

Backtrace for this error: #0 ffffffff" et je ne sais pas comment le résoudre.

Je dispose d'un module, du programme principal et d'un fichier source (il est en pièce jointe).

Après de nombreux affichages de 'print', le problème se situerait à l'entrée de la subroutine RKMerson.

Le code pour le module et le programme principal sont affichés en dessous, merci d'avance pour vos réponses, ce code étant déterminant pour la validation de mon année ...

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
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
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
MODULE mod_parametrage
 
    IMPLICIT NONE
 
    DOUBLE PRECISION:: z                                       ! abscisse
    DOUBLE PRECISION:: dz                                      ! pas de calcul
    INTEGER:: zmax                                             ! Longueur du réacteur
    INTEGER:: n                                                ! nombre de pas
    DOUBLE PRECISION,dimension(:,:),ALLOCATABLE:: Resultats            ! A l'appel ce tableau contient les valeurs y initiales
    INTEGER, PARAMETER::NbEquation=5                           ! nombre d'equations dans le systeme différentiel
    DOUBLE PRECISION,dimension(NbEquation):: F,Y
    DOUBLE PRECISION:: Debit
    INTEGER:: i,j,h                                            ! pour l'itération
    CHARACTER*20:: A                                           ! nom des données jamais de plus de 20 charactères
    DOUBLE PRECISION:: z1,z2,z3,z4,z5
    DOUBLE PRECISION,dimension(NbEquation):: y1,y2,y3,y4,y5,K1,K2,K3,K4,K5
    CONTAINS
 
SUBROUTINE init()
 
   ! 3) IL faut ouvrir un fichier texte, lire les valeurs initiales et les mettre en première colonne du tableau
 
    OPEN(unit = 10, file = 'fichier_source.txt', STATUS='OLD',ACTION='READ')
 
 
    ! 2) Déclaration des variables locales
 
    z = 0                                           ! Longueur initiale
    dz = 0.5                                        !Pas de calcul fixé
    zmax = 0                                        ! On teste une seule itération
    n = int(zmax/dz)+1                              ! Calcul du nombre de pas total
    ALLOCATE(Resultats(NbEquation,n+1))
 
 
 
    DO h = 1, NbEquation
 
        READ(10,*) A,Resultats(h,1)
 
        !PRINT*, A,Resultats(h,1)
 
    END DO
 
    CLOSE (10)
 
END SUBROUTINE init
 
 
SUBROUTINE RKMERSON(NbEquation,y,z,derivee)
 
    DOUBLE PRECISION::y(NbEquation),z,dz
    INTEGER::NbEquation
    DOUBLE PRECISION,dimension(NbEquation):: K1,K2,K3,K4,K5
    DOUBLE PRECISION,dimension(:,:),ALLOCATABLE:: Resultats
 
    ! Application de la méthode de Runge Kutta
 
    Do i = 1,NbEquation
 
        y(i)=Resultats(i,1)
 
    END DO
 
    PRINT*,'y'
 
 
    DO j = 1,n
 
        z=z+(dz*(j-1))
 
 
!calcul de K1
 
            PRINT*,'avant call derivee K1'
 
        CALL derivee(NbEquation,y1,z1,K1)
 
            z1=z
 
            DO i=1,NbEquation
                y1(i)=y(i)
            END DO
 
            PRINT*,'apres call derivee K1'
 
 
!calcul de K2
 
            CALL derivee(NbEquation,y2,z2,K2)
 
            z2=z+(dz/3)
            DO i=1,NbEquation
            y2(i)=y(i)+(dz/3)*K1(i)
            END DO
 
!calcul de K3
 
            CALL derivee(NbEquation,y3,z3,K3)
 
            z3=z+(dz/3)
            DO i=1,NbEquation
                y3(i)=y(i)+(dz/6)*(K1(i)+K2(i))
            END DO
 
 
!calcul de K4
 
            CALL derivee(NbEquation,y4,z4,K4)
 
            z4=z+(dz/2)
            DO i=1,NbEquation
                y4(i)=y(i)+(dz/8)*(K1(i)+3*K3(i))
            END DO
 
 
!calcul de K5
 
            CALL derivee(NbEquation,y5,z5,K5)
 
            z5=z+dz
 
            DO i=1,NbEquation
                y5(i)=y(i)+(dz/2)*(K1(i)-3*K3(i)+K4(i))
            END DO
 
!Calcul des nouvelles compositions
 
            Do i =1, NbEquation
                y(i)=y(i)+(dz/6)*(K1(i)+4*K4(i)+K5(i))
                Resultats(i,j+1)=y(i)
            End Do
 
    END DO
 
END SUBROUTINE RKMERSON
 
SUBROUTINE derivee(NbEquation,y,z,F)
 
    DOUBLE PRECISION:: c1,c2,c3,r1,r2,r3,rH2,rCH4,rB,rT,rD,S,diametre,pi,z
    DOUBLE PRECISION::y(NbEquation),F(NbEquation)
    INTEGER::NbEquation
 
 
    pi=3.14
    diametre=1
 
    S=pi*((diametre**2)/4)
 
 
    !attention P varie avec T PV=nRT
 
    c1= (3.6858*(10**6))*exp((-2.5616*10**4)/895)
    c2= 0.62717*exp((-1.5362*10**4)/895)
    c3= 0.08124*exp((-1.2237*10**4)/895)
 
    PRINT*,c1,c2,c3
 
 
    r1=(c1*y(4)*sqrt(y(1))*((550*6894.76)**(1.5)))      !1PSI=6894.76Pa
    r2=c2*(y(3)**2)*((550*6894.76)**2)
    r3=c3*y(5)*y(1)*((550*6894.76)**2)
 
    !PRINT*, r1,r2,r3
 
    rH2=-r1+r2-r3
    rCH4=r1
    rB=r1-2*r2+2*r3
    rT=-r1
    rD=r2-r3
 
    F(1)=(S*rH2)/Debit
    F(2)=(S*rCH4)/Debit
    F(3)=(S*rB)/Debit
    F(4)=(S*rT)/Debit
    F(5)=(S*rD)/Debit
 
    !PRINT*,F
 
END SUBROUTINE derivee
 
 
 
END MODULE mod_parametrage

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 PROGRAM ProgP
 
    USE mod_parametrage
 
    IMPLICIT NONE
 
    CALL init
 
    PRINT*,'avant RKMERSON'
 
    CALL RKMERSON(NbEquation,y,z,derivee)
 
    PRINT*,'apres RKMERSON'
 
 
    PRINT*,'Resultats', Resultats
 
 
 
 END PROGRAM ProgP

Bonjour,

Ajouter des print pour voir ce qui ce passe est une bonne idée.
Ajouter des option de débogage à la compilation pour mieux identifier les problèmes à l'exécution aide aussi souvent beaucoup.
Si on compile par exemple ces codes avec:
Code:

1 2 gfortran mod_parametrage.F90 ProgP.F90 -ffpe-trap=invalid,zero,overflow -fbounds-check -g3 -O0 -fstack-protector-all -finit-real=snan -fbacktrace -o ProgP
Alors l'exécution plante avec:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 ./ProgP avant RKMERSON At line 60 of file mod_parametrage.F90 Fortran runtime error: Index '1' of dimension 2 of array 'resultats' above upper bound of 0 Error termination. Backtrace: #0 0x401ac2 in __mod_parametrage_MOD_rkmerson at /home/Playground/tests_fortran/mod_parametrage.F90:60 #1 0x402fee in progp at /home/Playground/tests_fortran/ProgP.F90:12 #2 0x403130 in main at /home/Playground/tests_fortran/ProgP.F90:4
Le problème est donc lié à la ligne 60 de mod_parametrage; effectivement y est utilisé le tableau allouable "Resultats" alors que ce tableau n'a jamais été alloué...

28/12/2020, 17h07
Noemie_Vct

Remerciement

Merci beaucoup !

Je ne connaissais pas les options de débogage à la compilation, cela va mettre d'une grande aide !

Effectivement, je n'avais pas alloué le tableau au bon endroit.

Bonne soirée, et encore merci.
29/12/2020, 11h18
vmagnin

-g3
Citation:
Envoyé par Ehouarn

Code:

1 2 gfortran mod_parametrage.F90 ProgP.F90 -ffpe-trap=invalid,zero,overflow -fbounds-check -g3 -O0 -fstack-protector-all -finit-real=snan -fbacktrace -o ProgP
Merci, je ne connaissais pas l'option -g3
D'après ce que je lis ci-dessous, -g est équivalent à -g2 :
https://stackoverflow.com/questions/...the-difference
et -g3 ajoute des informations supplémentaires, en particulier concernant les macros (donc utile en C mais peut-être pas en Fortran ?).
29/12/2020, 14h16
Ehouarn

Bonjour,

Je n'ai pas d'arguments forts pour préconiser "-g3" (plutôt que "-g") vu que c'est à ma connaissance surtout pertinent pour l'utilisation d'un débogueur comme gdb.
En ce qui concerne l'aspect macro, il me semble que comme ces définitions sont au niveau du préprocesseur, elles pourraient s'appliquer aussi bien à du code Fortran que du C (mais personnellement je ne les utilises pas plus que ça; donc je dis peut-être là des bêtises).

A propos d'options pour aider au débogage, je réalise que j'ai oublié dans le lot "-Wall" qui donne souvent à la compilation des indications judicieuses sur de potentielles incohérences (utilisation d'une variable avant de l'avoir initialisé, etc.).