Intel® Fortran Compiler
Build applications that can scale for the future with optimized code designed for Intel® Xeon® and compatible processors.

Array SIZE>0 When Not ALLOCATED

ScottBoyce
Beginner
1,403 Views

I am not sure if this is a compiler bug or how Fortran is supposed to work, but if I allocate an allocatable array, then later deallocate it, then the SIZE function returns the size it was previously allocated with. 

PROGRAM ALLOCATOR
  !
  DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE:: X
  !
  ALLOCATE(X(10))
  !
  WRITE(*,*) SIZE(X),ALLOCATED(X)  ! >> 10  T
  !
  DEALLOCATE(X)
  !
  WRITE(*,*) SIZE(X),ALLOCATED(X)  ! >> 10  F
  !
END PROGRAM

Should it not return zero since the array no longer has any size?

 

Thanks

0 Kudos
10 Replies
Arjen_Markus
Honored Contributor I
1,403 Views

Such things are only reliable if the array has been allocated. Not a bug as such. It is at the same level as local variables in subroutines and functions not retaining their values between calls, even if they appear to (unless they have the SAVE attribute). The same goes for pointer variables.

0 Kudos
Steve_Lionel
Honored Contributor III
1,403 Views

As Arjen says, your program violates the Fortran standard by asking for the SIZE of an unallocated array. Here are the standard's words about the argument to SIZE:

shall be an array of any type. It shall not be an unallocated allocatable variable or a pointer that is not associated.

0 Kudos
Yavuz_D_
Beginner
1,403 Views

It is always possible to override (not technically) and use an alternative routine if it is necessary to make decisions based on the size of an array. 

PROGRAM ALLOCATOR
    DOUBLE PRECISION, DIMENSION(:), ALLOCATABLE:: X
    !
    ALLOCATE(X(10))
    !
    WRITE(*,*) SIZEO(X),ALLOCATED(X)  ! >> 10  T
    !
    DEALLOCATE(X)
    !
    WRITE(*,*) SIZEO(X),ALLOCATED(X)  ! >> 0  F

CONTAINS
!
FUNCTION SIZEO(VAR) RESULT(ASIZE)
    DOUBLE PRECISION, ALLOCATABLE:: VAR(:)
    INTEGER :: ASIZE
    IF (.NOT.(ALLOCATED(VAR))) THEN
        ASIZE = 0
    ELSE
        ASIZE = SIZE(VAR)
    END IF
END FUNCTION SIZEO
!
END PROGRAM

 

0 Kudos
Norman_K_
New Contributor I
1,241 Views

I came across this problem and forum post yesterday while teaching a post-doc some modern Fortran.

Please may I respectfully suggest a compiler flag which can raise a runtime error when we try to apply size to an unallocated array.

Or, for the standards committee...

size(a [,dim] [,stat] [,errmsg])

Thanks

Norman

0 Kudos
Steve_Lionel
Honored Contributor III
1,220 Views

/check:pointer should (but doesn't) check this.

0 Kudos
Norman_K_
New Contributor I
1,188 Views

I suppose the main frustration is that the standard does not define what should happen if an unallocated array or unassociated pointer is presented to size.  My preference would be 0.  What is not good is that Intel currently returns pseudo random answers, some of which may be plausible but wrong.

But thanks for the clarification.

0 Kudos
Steve_Lionel
Honored Contributor III
1,183 Views

The standard does indeed specify this:

ARRAY shall be assumed-rank or an array. It shall not be an unallocated allocatable variable or a pointer that is not associated.

Since you broke this rule, the result is undefined - which can be anything. The proper thing is for you to test that the argument is allocated or associated first.

0 Kudos
JohnNichols
Valued Contributor III
1,179 Views
  • I came across this problem and forum post yesterday while teaching a post-doc some modern Fortran.
  • ------------------------------------------------------------------------------------------------------
  • Re note on your teaching a post-doc -- they should have learnt this language before they reached the end of a PhD. 
  • personal opinion.
0 Kudos
jimdempseyatthecove
Honored Contributor III
1,161 Views

In C/C++

char* futz; // undefined
int len = strlen(futz);

Just what do you expect the value of len to become?

In Fortran, you do have the opportunity to test for ALLOCATED or ASSOCIATED prior to obtaining the SIZE.

Quirk RE Fortran. You can allocate to size of 0. Therfore, if you insist on interpreting SIZE == 0 as not allocated, then allocate to size of 0 (and document copiously what you are doing).

Jim Dempsey

0 Kudos
andrew_4619
Honored Contributor II
1,152 Views

As others have said Fortran has the allocated function.  Automatic run time checks would require additional code being executable pretty much every time you touch and allocatable. That sound like it would add inefficiency  instead of leaving it fully under user control.

0 Kudos
Reply