3

I am using gfortran 8.4 in Ubuntu with a deferred-length character variable as in the following example:

PROGRAM test
   IMPLICIT NONE
   CHARACTER(LEN=:),ALLOCATABLE :: str 
   str = '10'
END PROGRAM test

If I compile it using:

gfortran-8 test.f90 -o test -O0

When running the program using Valgrind I get a memory leak:

==29119== HEAP SUMMARY:
==29119==     in use at exit: 2 bytes in 1 blocks
==29119==   total heap usage: 22 allocs, 21 frees, 13,522 bytes allocated
==29119== 
==29119== LEAK SUMMARY:
==29119==    definitely lost: 2 bytes in 1 blocks
==29119==    indirectly lost: 0 bytes in 0 blocks
==29119==      possibly lost: 0 bytes in 0 blocks
==29119==    still reachable: 0 bytes in 0 blocks
==29119==         suppressed: 0 bytes in 0 blocks

However, compiling the program with:

gfortran-8 test.f90 -o test -O1

I get in Valgrind:

==29130== HEAP SUMMARY:
==29130==     in use at exit: 0 bytes in 0 blocks
==29130==   total heap usage: 21 allocs, 21 frees, 13,520 bytes allocated
==29130== 
==29130== All heap blocks were freed -- no leaks are possible

I do not understand why I am getting this memory leak when no optimization is applied at compile time. Thanks in advance.

Emilio
  • 190
  • 1
  • 3
  • 10
  • 1
    (Just by head some thoughts) probably with `-O1` the code is optimized out as it is not used and with `-O0` no optimization is done at all. Try also to place a `write(*,*) str` after the assignment and see what happens. – albert Jun 16 '20 at 14:21
  • You are right, with -O1 the code is optimized out and that is why it is not showing the memory leak. In any case I do not understand why this memory leak happens. – Emilio Jun 16 '20 at 14:25
  • Apparently valgrind sees what is left in memory before the closing end no dealloactions have been taken place (str is still in scope). – albert Jun 16 '20 at 14:29
  • 2
    As with a [related question](https://stackoverflow.com/q/61098780/3157076) one may suspect this is an issue with valgrind's detection rather than gfortran's interpretation of a non-leaky program. – francescalus Jun 16 '20 at 14:38
  • 1
    valgrind does not understand an executable produced by a Fortran compiler. – evets Jun 26 '20 at 18:28

2 Answers2

7

All variables declared in the main program or as module variables are implicitly save. Saved variables are not automatically deallocated. The Fortran standard does not mandate deallocation of arrays at the end of the program. They will be reclaimed by your OS anyway.

You can deallocate your arrays manually or if you wish to get automatic reallocation, you can move that logic - and the allocatable variables - into a subroutine that is entered from the main program. That way the local allocatable variables of that subroutine will be deallocated when the subroutine finishes.

Alternatively, you can also create a block using block and end block and declare the allocatable variables inside the block with all that it brings. They will be deallocated when the execution of the block is finished.

Technically what happens is that code generated by the compiler for your program does not maintain the pointers inside the allocatable descriptors until the moment valgrind would like to see them for them to be "still reachable". That is a technicality that you do not have to worry about.

Vladimir F Героям слава
  • 57,977
  • 4
  • 76
  • 119
1

It might not be perfectly nice to let the OS do the memory cleanup for a variable that has a lifetime until the end of a program, but it's still valid.

To avoid these false positive leaks in valgrind it is sufficient to enclose your code in a scope contained in the main program using the block construct.

mcocdawc
  • 1,748
  • 1
  • 12
  • 21