Check if array is allocatable in fortran

Question

In fortran it is possible to check if an allocatable array is allocated using the allocated statement:

program test_allocated
  integer :: i = 4
  real(4), allocatable :: x(:)

  print *, 'before allocation of x'
  print *, 'allocated(x)'
  print *, allocated(x)

  allocate(x(i))
  print *, 'after allocation of x'
  print *, 'allocated(x)'
  print *, allocated(x)

end program test_allocated

However, is it also possible somehow to check if a regular array was declared as allocatable? The following code

program test_allocated
  integer :: i = 4
  real(4), allocatable :: x(:)
  real(4)::y
  print *, 'before allocation of x'
  print *, 'allocated(x)'
  print *, allocated(x)
  print *, 'allocated(y)'
  print *, allocated(y)
  allocate(x(i))
  print *, 'after allocation of x'
  print *, 'allocated(x)'
  print *, allocated(x)
  print *, 'allocated(y)'
  print *, allocated(y)
end program test_allocated

throws an error

D:\TEMP\FortranTest\ifort>ifort test.f90
Intel(R) Visual Fortran Intel(R) 64 Compiler XE for applications running on Inte
l(R) 64, Version 13.0.1.119 Build 20121008
Copyright (C) 1985-2012 Intel Corporation.  All rights reserved.

test.f90(9): error #6547: The ARRAY argument of the ALLOCATED inquiry intrinsic
function shall be an allocatable array.   [Y]
  print *, allocated(y)
---------------------^
test.f90(15): error #6547: The ARRAY argument of the ALLOCATED inquiry intrinsic
 function shall be an allocatable array.   [Y]
  print *, allocated(y)
---------------------^
compilation aborted for test.f90 (code 1)

Perhaps another statement or method to inquire the nature of the array exists?

There is no way to do that in standard Fortran. Perhaps if you explain why you want to check the allocation status of not-allocatable entities someone might be able to find a clever solution to that problem. — High Performance Mark, Aug 27 '17 at 15:44
Fortran is a static language, in that the compiler knows if a variable is a fixed array, or an allocatable array. But Fortran does not have reflection where this information is available to the program itself (unlike C# for example). — John Alexiou, Aug 27 '17 at 15:46
Possible duplicate of [Internal memory representation of Fortran allocatable](https://stackoverflow.com/questions/42442512/internal-memory-representation-of-fortran-allocatable) — Rodrigo Rodrigues, Oct 19 '18 at 19:08

score 2 · Answer 1 · edited Jun 20 '20 at 09:12

Some compilers store metadata of the array in a dope array descriptor, including attributes like allocatability, contiguity, element storage size, definition status, if it's a pointer... They are needed internally by the language to check interface matching on specific procedure calls.

So, it's technically possible to inspect this kind of meta information, but it's also hardly useful to do so. Again, Fortran is statically typed and the compiler is able to do all this checks at compile-time.

Moreover, the language is designed in a way that you can only handle allocation on a variable (or a dummy argument) when you explicitly declared it to be allocatable (or pointer). In all other cases, you can use an array without bothering how it was allocated.

See this forum thread:

Once you have allocated an allocatable array, it is now an array as "good" as any other and it can be passed as an actual argument to procedures (or C functions) that don't even need to know that it is allocatable. The same applies to pointer arrays, I might add, though there is one slight caveat to that case (involving the possibility that a pointer array might point to a non-contiguous slice).

For your specific case, you are trying to use the intrinsic function allocated with a non-allocatable array y, giving the error. You don't need to check if an array is allocatable before using this function on it, you just need to know that, if you didn't explicity declare it as allocatable (as you did with x), it is not.

Same way, if you want to manage allocation of a variable inside a function or subroutine, you just need to declare the dummy argument as allocatable, and you are guaranteed that only allocatable variables will be accepted by the procedure (same with pointers).

If, by any chance, you have strong reasons to poke with internal representation of variables and you know what you're doing, you can refer to this answer from @VladmirF on other question or dive into the reference manual of your specific compiler. Also, recent versions of the standard specify a standardized array descriptor, aiming interoperability with c code.

Lastly, as you tagged Intel in this question, I'll point you to the Intel compiler reference on the matter, where you can see that:

The downside to using array descriptors is that it can increase the opportunity for errors. Additionally, the corresponding code is not portable. Specifically:

If the descriptor is not defined correctly, the program may access the wrong memory address, possibly causing a General Protection Fault.

Array descriptor formats are specific to each Fortran compiler. Code that uses array descriptors is not portable to other compilers or platforms.

The array descriptor format may change in the future.

If the descriptor was built by the compiler, it cannot be modified by the user. Changing fields of existing descriptors is illegal.

The components of the current Intel® Fortran array descriptor on systems using IA-32 architecture are as follows:

Bytes 0 to 3 contain the base address.

(...)

Bytes 12 to 15 contain a set of flags used to store information about the array. This includes:

bit 1 (0x01): array is defined -- set if the array has been defined (storage allocated).

(...)

bit 8 (0x80): set if the array pointed to is ALLOCATABLE.

Other bits are reserved.

Check if array is allocatable in fortran

1 Answers1

Linked