Fortran anomalie de segmentation étrange

Question

J'ai un problème avec mon code principal, j'ai donc essayé d'isoler le problème. Par conséquent, j'ai ce petit code:

MODULE Param 
    IMPLICIT NONE 

    integer, parameter :: dr = SELECTED_REAL_KIND(15, 307) 
    integer     :: D =3 
    integer     :: Q=10 
    integer     :: mmo=16 
    integer     :: n=2 
    integer     :: x=80 
    integer     :: y=70 
    integer     :: z=20 
    integer     :: tMax=8 
END MODULE Param 

module m 
contains 
    subroutine compute(f, r) 
     USE Param, ONLY: dr, mmo, x, y, z, n 
     IMPLICIT NONE 

     real (kind=dr), intent(in) :: f(x,y,z, 0:mmo, n) 
     real (kind=dr), intent(out) :: r(x, y, z, n) 
     real (kind=dr) :: fGlob(x,y,z, 0:mmo) 
     !------------------------------------------------------------------------- 

     print*, 'We are in compute subroutine' 

     r= 00.0 

     fGlob=sum(f,dim=5) 
     r=sum(f, dim=4) 

     print*, 'fGlob=', fGlob(1,1,1, 1) 
     print*, 'f=', f(1,1,1, 0,1) 
     print*, 'r=', r(1,1,1, 1) 
    end subroutine compute 
end module m 


PROGRAM test_prog 
    USE Param 
    USE m 
    Implicit None 

    integer :: tStep 
    real (kind=dr), dimension(:,:,:, :,:), allocatable :: f 
    real (kind=dr), dimension(:,:,:,:), allocatable :: r 
    !---------------------------------------------------------------------------- 

    ! Initialise the parameters. 
    print*, 'beginning of the test' 

    ! Allocate 
    allocate(f(x,y,z, 0:mmo,n)) 
    allocate(r(x,y,z, n)) 

    f=1.0_dr 

    ! --------------------------------------------------------- 
    !  Iteration over time 
    ! --------------------------------------------------------- 
    do tStep = 1, tMax 
     print *, tStep 
     call compute(f,r) 
     f=f+1 
     print *, 'tStep', tStep 
    enddo 

    print*, 'f=', f(1,1,1, 0,1) 
    print*, 'r=', r(1,1,1, 1) 

    ! Deallacation 
    deallocate(f) 
    deallocate(r) 
    print*, 'End of the test program' 
END PROGRAM test_prog 

Pour l'instant, je ne suis pas en mesure de comprendre pourquoi quand je compilez avec ifort, j'ai un segmentation fault, et il fonctionne quand je compilez avec gfortran. Et pire, quand je compile avec à la fois ifort et gfortran avec leurs options fast, je reçois à nouveau une erreur segmentation fault (core dumped). Et plus confus, quand j'ai aussi essayé avec les deux compilateurs de compiler avec traceback options, tout fonctionne bien.

Je sais que segmentation fault (core dumped) erreur signifie généralement que j'essaie de lire ou d'écrire dans un mauvais emplacement (indices de matrice etc ...); mais ici avec ce petit code, je ne vois aucune erreur comme celle-ci.

Est-ce que quelqu'un peut m'aider à comprendre pourquoi ces erreurs se produisent?

Answer 1

Le problème vient de la taille de la pile utilisée par certains compilateurs par défaut (ifort) ou par d'autres quand ils optimisent la compilation (gfortran -Ofast). Ici, nos écrits dépassent la taille de la pile.

Pour résoudre ce problème, j'utilise les options -heap-arrays pour le compilateur ifort et -fno-stack-arrays pour le compilateur gfortran.