5

Pretty simple setup, using gfortran 4.8.5 on linux (red hat):

  • I get a segfault if my array of reals (inside a derived type) has size > 2,000,000. This seems to be a standard stack/heap issue as my stack size is 8mb if I check with ulimit.

  • There is no problem if the array is NOT inside a derived type

  • Note that as @francescalus guesses, removing the initial value = 0.0 eliminates the problem

Edit to add: Note that I have posted a followup question Segmentation fault related to component of derived type that represents a more realistic use case and further narrows down the conditions under which this seems to occur.

program main

    call sub1     ! seg fault  if col size >   2,100,000
    call sub2     ! works fine at col size = 100,000,000  

end program main

subroutine sub1

    type table
        real :: col(2100000) = 0.0     ! works if "= 0.0" removed
    end type table

    type(table) :: table1
    table1%col = 1.0

end subroutine sub1

subroutine sub2
    real :: col(100000000) = 0.0
    col = 1.0
end subroutine sub2

Some obvious questions here:

  • Is this expected behavior, or some bug that was fixed in newer versions of gfortran?

  • Am I following standard fortran operating procedures here, or doing something wrong?

  • What is the recommended way to avoid this (please assume that I am unable to update to a newer version of gfortran in the near term)? I will almost certainly solve with an allocatable array component for reasons not specific to this question, but that might not be an ideal general solution and I would like to know of all good options I have here.

  • In particular, is initializing the components of a derived type bad practice?

Improve this question
7
  • Do you have any particular desired "fix"? That is, are you open to changes to the code (not just the allocatable component), or just compiler flags, etc.? Commented Aug 23, 2018 at 12:52
  • 3
    I'm not an expert in gfortran so can't give you an answer. However, it seems that the problem is the default initialization of the derived type: removing that, if possible, may be good enough. [Note that the default initialization of the component, and the explicit initialization in sub2 do mean different things.] Commented Aug 23, 2018 at 13:15
  • 1
    @HighPerformanceMark I attempted to make an MCVE stackoverflow.com/help/mcve I could certainly make it a lot longer and more "useful". The actual code I'm using puts the subroutine in a module but has the same problem. I wasn't sure if I should do as I did here or use a "contains" to emulate the actual modularization. The use of 2 "pointless" subroutines with no arguments is merely to separate them fully and not have 2 programs. sub2 is just for comparison and not of particular interest on its own. Commented Aug 23, 2018 at 14:42
  • 1
    @JohnE, static initialization of variables and arrays will often be placed on the stack. gfortran has a -fstack-array option. It may have its negation, ie, -fno-stack-array, which may prevent use of the stack. This probably increases the code size and runtime. In the end, this isn't a gfortran problem. It's a problem with your environment exposed by a Fortran program. Using a different compiler may also hit the stack limit. Commented Aug 23, 2018 at 17:14
  • 1
    Note that the compiler options that gfortran developer @Steve discusses in his comment above are in fact -fstack-arrays and (absent from the man page) -fno-stack-arrays, with plural arrays in both cases. Unfortunately, with gfortran 7.3.0 and 8.2.0, -fno-stack-arrays does not seem to fix the issue here. Commented Aug 23, 2018 at 17:39

2 Answers 2

Reset to default
6

This is likely to be a runtime issue due to insufficient stack, rather than a bug with gfortran.

Gfortran uses the stack to store automatic arrays and other initialization data. When code does not create problems when one such array is small, but segfaults when the size of the array increases, a possible reason is running out of stack.

The issue seems to be the same in more recent versions of gfortran. I compiled and ran your program with gfortran 4.8.4, 4.9.3, 5.5.0, 6.4.0, 7.3.0 and 8.2.0. In all cases I obtained a segmentation fault with the default stack size, but no error when the stack size was slightly increased.

$  ./sfa
Segmentation fault
$ ulimit -s
8192
$ ulimit -s 8256 
$ ./sfa && echo "DONE"
DONE

Your problem may be solved by running

$ ulimit -s unlimited

before executing your binary. I am not aware of any particular penalty for doing this, but programmers more aware of the fine details of memory management, such as compiler developers, may think otherwise.

Initializing the components of a derived type is not bad practice, but as you can see, it can create problems with the stack if the component is a big array - be it due to the storage of the component itself, or to the storage of memory to work on the RHS of the assignment. If the component is made allocatable and allocated in a subroutine, the array is stored in the heap rather than in the stack, and this issue is usually avoided. In this case, it may be about actually setting the values of the array dynamically in a subroutine rather than at compile time. It may be less elegant, but I think it's worth it, since it's the typical example of code development work that prevents avoidable, environment-related errors when executing the binary.

Your code above is standards compliant. As explained in the comments, lack of explicit interfaces for subroutines is not good practice, but for these simple subroutines it's not against the rules.

Some compilers have flags that allow you to change where some objects are allocated in memory. While it may fix a particular issue, flags are compiler dependent, and usually not equivalent when comparing different compilers. Using dynamic memory via allocatables is a more robust solution, according to my experience.

Finally, note that, if you are using OpenMP, the ulimit command above only affects the master thread - you need to set the stack size of each of the other threads via the environment variable OMP_STACKSIZE, which cannot be unlimited. And bear in mind that non-master threads running out of stack are a problem much more difficult to diagnose, since the binary may stop without a proper Segmentation fault error.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Thanks for the answer and I have selected it although I still have some further questions (I may add a bounty to this or the followup question to this one). In particular, I'd like a better understanding of pros & cons of unlimited stack size and also the relationship between the stack size (ulimit- s) and the compiler options like, say, -fmax-stack-var-size. That's not a request to add to your answer (though feel free to), just an explanation of my further questions that I am trying to followup on. But thanks again, good answer!
0

These are not necessarily useful solutions, but below are some conditions under which the seg fault disappears. A couple of people mentioned the lack of an explicit interface (as bad practice though not technically incorrect), and it seems that this might be one key here as either of these two changes to the code gets rid of the seg fault, although it's not quite that simple, as I'll explain:

  1. Put everything in main, with no subroutine calls

  2. Put the type definition table in a module

Let me expand on #2 briefly. Simply taking the example in the OP and then giving it an explicit interface by putting the subroutine in a module does NOT work. However, if I put the type definition in a module and then use it (as shown below) the segfault does not occur:

program main

    use table_mod

    type(table) :: table1

    table1%col = 1.0

end program main
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.