Discussion :

[dva2tlse]

Bonsoir et salut les développeurs,
je suis en train de faire des essais avec un programme en fortran que
j'ai écrit; il me plante une SEGFAULT après N'avoir lu QUE 10700 entiers
(codés sur huit octets, il est vrai) alors que je suis parti pour bien
plus.
J'ai essayé "ulimit -s unlimited", mais ça change rien,
Alors que faire ?
David

[Ehouarn]

Bonjour,
Premier réflexe à avoir: compiler et exécuter avec toutes les options de debug proposées par le compilateur pour voir si le pb n'est pas tout simplement dans le code source.
Bon courage.

[vmagnin]

Bonjour David,

est-ce que vous pouvez nous donner plus d'informations :

• OS ?
• Compilateur ?
• Que fait le programme ?
• Quelle est sa structure ?
• ...

Peut-être que cette discussion parlant de ulimit -s unlimited et -fmax-stack-var-size peut aider :
https://fortran-lang.discourse.group...nlimit-s/2970/

[dva2tlse]

Bonjour Ehouarn et vmagnin,
je suis super-content d'avoir vos réponses ce midi; l'heure à laquelle vous les avez postées me rappelle l'époque où je bossais et où j'allais voir sur les forums pendant que le café coulait, vers cette heure là aussi, ou même encore plus tôt parfois.

Bon alors maintenant, des réponses :
-1°) la compil' : j'utilise un scriptPourBuildersqBI (sqBI est le nom du programme).
sPBsqqBI:
#!/bin/sh
# scriptPourBuildersqBI=sPBsqBI dans $HOME/FORTRAN/FPRM
rm *.o commod.mod
gfortran -c commod.f
gfortran -c sqBI.f
gfortran sqBI.o commod.o -fbounds-check -fdefault-integer-8 -std=f2018 -fno-backtrace -fcheck=all -o sqBI
./sqBI

Vous voyez qu'il y a bien toutes les options qui permettent de corriger une SEGFAULT "facile", mais celle-là a l'air "costaude".

-2°) OS: Xubuntu 22.04 dans un PC assemblé. Compilo' : gfortran comme vu plus haut

-4°) But du prgm : Euler project #3, stocker des drapeaux disant si un nombre est premier jusqu'à entre 7 et 8 milliards.

BI=600851475143_int64
c
c six cents milliards, huit cent cinquante et un millions,
c quatre cent soixante quinze mille, cent quarante trois.

-5°) Structure du prgm : Au tout début du crinle d'Érastothènes, que j'applique pour avoir chaque nouveau nombre premier, je dois stocker des drapeaux disant si un nombre est premier ou pas.
Voici l'instruction fautive :
sqBI.f:
IsqBI=INT(SQRT(REAL(BI)))
do i=1, IsqBI
print*, 'i=', i, ', is_p(i) =', is_p(i)
enddo
.
..
...
print*, 'i=', i, ', is_p(i) =', is_p(i)

.
..
...
i= 15067 , is_p(i) = 0
i= 15068 , is_p(i) = 0
i= 15069 , is_p(i) = 0
i= 15070 , is_p(i) = 0

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



-6°) https://fortran-lang.discourse.group...nlimit-s/2970/ :

Trop compliqué pour moi.





Merci et bye,
DAVID

[Ehouarn]

-1°) la compil' : j'utilise un scriptPourBuildersqBI (sqBI est le nom du programme).
sPBsqqBI:
#!/bin/sh
# scriptPourBuildersqBI=sPBsqBI dans $HOME/FORTRAN/FPRM
rm *.o commod.mod
gfortran -c commod.f
gfortran -c sqBI.f
gfortran sqBI.o commod.o -fbounds-check -fdefault-integer-8 -std=f2018 -fno-backtrace -fcheck=all -o sqBI
./sqBI

Vous voyez qu'il y a bien toutes les options qui permettent de corriger une SEGFAULT "facile", mais celle-là a l'air "costaude".

Il faut mettre les options de debug à la compilation des codes sources et pas seulement lors de l'assemblage des objets, il me semble.
J'ajoute en général les options pour initialiser les valeurs à NaN, e.g. "-finit-real=snan" et le signalement des opérations illicites "-ffpe-trap=invalid,zero,overflow".
Et pourquoi mettre "-fno-backtrace" ? Ca demande à ne pas avoir d'info (la ligne du code) sur le plantage... plutôt contre-productif non ? "-fbacktrace" c'est bien mieux.

En espérant que ça t'aide à identifier ton problème.

[vmagnin]

Bonjour David,

tu peux essayer d'utiliser l'utilitaire valgrind pour analyser l'utilisation de la mémoire :
http://sdz.tdct.org/sdz/debuguer-fac...-valgrind.html
Les programmes d'exemples sont en C, mais c'est pareil. Tu tapes

Code :

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

$ valgrind ./a.out

Ca pourrait aussi être intéressant d'utiliser une autre version de GFortran pour voir (dans Ubuntu on a toujours les 4 dernières versions à disposition). Ou d'utiliser les compilateurs Intel Fortran ifort et ifx, que l'on peut installer gratuitement depuis 2020. Voir les instructions ici :
https://doc.ubuntu-fr.org/fortran#in...rtran_compiler

[dva2tlse]

je ne sais pas lire les résultats d'une backtrace.

[Ehouarn]

je ne sais pas lire les résultats d'une backtrace.

Pas sûr de comprendre; c'est du texte simple pourtant; c'est l'anglais qui te défrise?

Par ce que c'est quand même bien pratique de simplement demander au compilo où et pourquoi ça plante. Je ne résiste pas à mettre un petit exemple:

Code :

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

1
2
3
4
5
6
7
8
9
10
program prog_bug
implicit none
integer :: i
real :: tab(10)
 
do i=1,12
 tab(i)=i*i
enddo
 
end program prog_bug

Code :

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

1
2
3
4
5
6
7
8
9
 
# gfortran prog_bug.f90 -Wall -ffpe-trap=invalid,zero,overflow -fbounds-check -finit-real=snan -fbacktrace -o prog_bug
# ./prog_bug 
At line 7 of file prog_bug.f90
Fortran runtime error: Index '11' of dimension 1 of array 'tab' above upper bound of 10
 
Error termination. Backtrace:
#0  0x40078a in prog_bug
	at /..../prog_bug.f90:7

[dva2tlse]

J'ai aussi demandé qu'on m'aide sur le forum d'ubuntu. https://forum.ubuntu-fr.org/viewtopic.php?id=2076040

Pouvez vous y reprendre le programme que j'ai élagué et essayer de compiler elag.f

[vmagnin]

J'ai réorganisé un peu cette partie de 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
 
      print*, ' Initialisation :'
      print*, 'is_p=(/ 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1 /)'
      print*, '        1  2  3  4  5  6  7  8  9 10 11'
      NN=BI
      IsqBI=INT(SQRT(REAL(BI)))
      allocate(is_p(IsqBI))
      is_p = 0
c     ! J'assigne les is_p, et ça donne ça :
      !is_p=(/0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1/) ! NE PAS faire is_p[1:11]
      print*, 'lbound(is_p, 1)=', lbound(is_p, 1) ! =1
      print*, 'ubound(is_p, 1)=', ubound(is_p, 1) ! =11
c     !
      print*, 'IsqBI=', IsqBI
      do i=1, IsqBI
          print*, 'i=', i, ', is_p(i) =', is_p(i)  ! =0 GAML si is_p[1:11]=constructor 5/qq L.+Ht
      enddo

is_p() est un tableau allouable, j'ai donc ajouté un allocate(is_p(IsqBI))
et je l'ai initialisé entièrement avec des zéros. Maintenant la boucle va jusqu'au bout.

A noter que dans le script de compilation, j'ai mis les mêmes options de compilation sur les trois commandes gfortran. Ca m'a aidé à trouver le problème.

Remarque en passant, c'est curieux, tu mixes le Fortran moderne (modules, iso_fortran_env, etc.) avec le format de fichier "fixed form" (avec les c en première colonne pour les commentaires, code commençant en colonne 6). Pourquoi ne pas utiliser le format dit "Free form" introduit par la norme Fortran 90 ? Le fixed form ne devrait être utilisé que pour travailler sur des codes legacy. Pour les bonnes pratiques voir https://fortran-lang.org/en/learn/

[dva2tlse]

Non, l'anglais, surtout technique ne me gêne pas du tout;

[dva2tlse]

pour info je suis ingénieur, en calcul de structures, et la boite où je bossais est devenue sous traitant d'airbus pour les plans des mâts-réacteur, alors l'anglais, j'en ai bouffé.
J'ai appris le fortran en stage d'avant-dernière année d'école, en 1980.
David

[vmagnin]

Pour complément, je pense que le fait de ne pas mettre ALLOCATE() impliquait que la ligne suivante :

Code :

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

1
2
3
4

is_p=(/0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1/)

allouait au tableau 11 éléments.

Comme -fbounds-check n'était pas présent dans la commande de compilation d'elag.f, la boucle continuait jusqu'à ce qu'on sorte de la zone mémoire allouée au programme (heap).