Compile-time warning to declare array as sequence

Question

I'm encountering a compile-time warning when passing arrays to MPI calls by referencing their first value. Consider the following example code, which is the leanest I could get:

module mymod
implicit none
contains

subroutine test_sequence(input,output,icomw,N)
use MPI
integer, intent(in), contiguous :: input(:)
integer, intent(in) :: icomw, N
integer, intent(out) :: output(:)
integer :: ier

write(*,*) 'in sub: ', is_contiguous(input), is_contiguous(output)

call MPI_REDUCE(input(1),output(1),N,MPI_INTEGER,MPI_MAX,0,icomw,ier)
   ! -- This is the line referenced in the error

end subroutine test_sequence
end module mymod

program main
use MPI
use mymod
implicit none
integer :: icomw, id, nproc, ier, N, i
integer, allocatable :: input(:), output(:)
real :: harvest

call MPI_INIT(ier)
icomw = MPI_COMM_WORLD

N = 10
allocate(input(N), output(N))
input = 1

write(*,*) 'in main: ', is_contiguous(input), is_contiguous(output)

call test_sequence(input,output,icomw,N)

call MPI_FINALIZE(ier)
end program main

Notice that I'm passing MPI_REDUCE only the first element of input and output but using a count of N, which is (in this case) the complete size of the array. It's worth noting that referencing array sections like this probably isn't best practice but I'm doing it anyway.

I get the following compiler warning and runtime output:

km-gs3% mpifort test_sequence.f90
PGF90-W-0312-Array input should be declared SEQUENCE (test_sequence.f90: 14)
PGF90-W-0312-Array output should be declared SEQUENCE (test_sequence.f90: 14)
  0 inform,   2 warnings,   0 severes, 0 fatal for test_sequence
km-gs3% mpirun -np 2 ./a.out 
 in main:   T  T
 in sub:   F  F
 in main:   T  T
 in sub:   F  F

I get the warning with PGI 14.3/OpenMPI 1.8.0 or PGI 15.5/OpenMPI 1.8.6. I do not get the warning with PGI 12.9/OpenMPI 1.6.2, PGI 14.3/OpenMPI 1.6.5, or Intel 14.0/OpenMPI 1.8.0.

It's my understanding that sequence is a keyword affecting derived data types only, and input and output here are plain integers. Also, these are 1D arrays - don't they have to be contiguous anyway?

My question is: what's going on here? Can (and should) I declare integers as sequence?

Edit 1 Following the advice of francescalus, I've attempted to define the the dummy array as contiguous. I've added contiguous to the input argument and inquired about the contiguity (is that a word?) of input and output using is_contiguous in main and sub. Rather than re-post the entire code, I've edited the original code shown above. Unfortunately, I still get the same compiler warning. Furthermore, the contiguous attribute doesn't seem to be doing anything because is_contiguous reports false in the subroutine for both input and output.

Am I using the contiguous attribute correctly? It seems reasonable to require input and output to be contiguous, but not sequence. Perhaps I should report this to PGI directly, especially now that I've encountered the problem on a reasonably new version of pgfortran.

In the subroutine, input is contiguous even without the contiguous attribute, so the result of is_contiguous surprises. — francescalus
– francescalus, Commented Sep 1, 2015 at 20:07
@francescalus surprises indeed. Intel 14.0 gives true for is_contiguous everywhere for both input and output. — Ross
– Ross, Commented Sep 1, 2015 at 21:01
I've posted a related (but simpler, for now) question on PGI's forums here: pgroup.com/userforum/viewtopic.php?t=4882 — Ross
– Ross, Commented Sep 1, 2015 at 21:35

francescalus · Accepted Answer · 2015-09-01 07:24:24Z

2

I don't have access to the same setup to be able to replicate, but there are some things still to say.

The sequence attribute can indeed apply only to derived types. That means you can't (and shouldn't) declare input and output with sequence.

Now, after we note that what you see is a warning (which has prompted you to think about the problem - which you can do more than the compiler can), what are the other concerns?

There are several implications that come from being a sequence type. Continguity is an important one, and is addressed in your penultimate question.

A 1D dummy argument, such as input, needn't be contiguous. Consider

  real a(11), b(5)
  call sub(a(1::5))    ! Look at the stride
  call sub(b(5:1:-1))  ! Look at the order

contains

   subroutine sub(input)
     real, intent(in) :: input(:)
   end subroutine

end program

In general, in Fortran we don't have to care about the contiguity or otherwise of dummy arguments. There is, though, the is_contiguous intrinsic function which inquires of the contiguity of an array.

When interfacing with other things there may be reason to worry. There are some things you can do here:

thorough testing (how does the compiler/MPI environment really handle things?)
add the contiguous attribute to the dummy arguments
pass the arrays themselves to MPI_Reduce, not the first elements

answered Sep 1, 2015 at 7:24

francescalus

32.9k28 gold badges86 silver badges128 bronze badges

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

4 Comments

Vladimir F Героям слава Over a year ago

Looks like PGF actually means contiguous when they write sequence. It is the sequence association that is happening after all.

francescalus Over a year ago

That makes sense. If Ross can confirm that the message goes away with contiguous I'll add to the answer.

Ross Over a year ago

@francescalus Thanks for the answer. I've attempted to use contiguous with no success. I've updated my answer just now. I also tried a very recent version of PGF.

Ross Over a year ago

My question just now, sorry.

Ross · Accepted Answer · 2015-09-08 22:12:29Z

1

I've now got some closure on this issue and wanted to share. This answer will hopefully provide some clarity for future readers. Thanks francescalus and Vladimir F for your help; I also received help on the Portland Group Forums.

There are two separate bugs in pgfortran at play here. The first is a bug in the is_contiguous intrinsic. The second is an erroneous use of a legacy warning. Both issues have been reported and will (hopefully) be fixed in a new compiler release.

Issue with `is_contiguous`

is_contiguous isn't performing as expected. The bug has been reported with tag TPR#21939. Consider the following example code:

module mymod 
implicit none 
contains 

subroutine mysub(ia1,ia2) 
integer, intent(in), contiguous :: ia1(:) 
integer, intent(in) :: ia2(:) 

write(*,*) 'in sub: ', is_contiguous(ia1), is_contiguous(ia2) 

end subroutine mysub 
end module mymod 

program main 
use mymod 
implicit none 

integer, allocatable :: ia1(:), ia2(:) 
integer :: N 

N = 10 
allocate(ia1(N), ia2(N)) 

write(*,*) 'in main: ', is_contiguous(ia1), is_contiguous(ia2) 

call mysub(ia1,ia2) 

end program main

which gives the following output:

km-gs3% pgfortran test_contiguous.f90; ./a.out 
 in main:   T  T 
 in sub:   F  F 
km-gs3% pgfortran --version 

pgfortran 15.5-0 64-bit target on x86-64 Linux -tp piledriver 
The Portland Group - PGI Compilers and Tools 
Copyright (c) 2015, NVIDIA CORPORATION.  All rights reserved.

Both input and output are contiguous, and I'm even assigning ia1 the contiguous attribute. Yet is_contiguous reports them to be not contiguous in mysub.

Warning to Declare as `sequence`

This is the original issue that led to this question - a compile-time warning to declare an array as sequence. This issue has been reported with tag TPR#21947. Consider the following example code:

module mymod 
implicit none 
contains 

subroutine test_sequence(input,output,icomw,N) 
use MPI 
integer, intent(in) :: input(:) 
integer, intent(in) :: icomw, N 
integer, intent(out) :: output(:) 
integer :: ier 

call MPI_REDUCE(input(1),output(1),N,MPI_INTEGER,MPI_MAX,0,icomw,ier) 
   ! -- This is the problem line referenced in the warning 

end subroutine test_sequence 
end module mymod 

program main 
use MPI 
use mymod 
implicit none 
integer :: icomw, id, nproc, ier, N, i 
integer, allocatable :: input(:), output(:) 
real :: harvest 

call MPI_INIT(ier) 
icomw = MPI_COMM_WORLD 

N = 10 
allocate(input(N), output(N)) 
input = 1 

call test_sequence(input,output,icomw,N) 

call MPI_FINALIZE(ier) 
end program main

As mentioned in the question, I'm passing the entire input and output array to MPI_REDUCE by referencing the first element in each array and assigning a size of N. This is not good practice, but I was doing it anyway. I get the following compile-time warning:

[chaud106@hyperion-login-1 Testing]$ mpif90 test_sequence.f90 
PGF90-W-0312-Array input should be declared SEQUENCE (test_sequence.f90: 12) 
PGF90-W-0312-Array output should be declared SEQUENCE (test_sequence.f90: 12) 
  0 inform,   2 warnings,   0 severes, 0 fatal for test_sequence

[chaud106@hyperion-login-1 Testing]$ mpif90 --version

pgf90 14.3-0 64-bit target on x86-64 Linux -tp piledriver 
The Portland Group - PGI Compilers and Tools
Copyright (c) 2014, NVIDIA CORPORATION.  All rights reserved.
[chaud106@hyperion-login-1 Testing]$ mpirun --version
mpirun (Open MPI) 1.8

Report bugs to http://www.open-mpi.org/community/help/

which is incorrect because arrays (like input) may not be defined as sequence.

edited Sep 8, 2015 at 22:12

answered Sep 8, 2015 at 20:35

Ross

2,18616 silver badges26 bronze badges

4 Comments

Ross Over a year ago

@francescalus good points. I've edited my answer to include ia2 to be contiguous. I'm unfamiliar with the term element sequence but I would be unhappy to see the warning turned into an error as mkcolg suggests on the Portland forum. Perhaps you'd like to post there yourself?

francescalus Over a year ago

[Tidied up the wrong comment first, so context lacking.] Whether there is an error depends on the dummy argument. From memory, pre-MPI 3 the arguments of MPI_Reduce are assumed-size, so this element sequence (see F2008 12.5.2.11) is permitted. However, I could be wrong (it's been a while since I looked at this) and with the interface actually assumed-shape. (And this is potentially a difference between the module and mpif.h, and in particular the mpi_f08 module and that with assumed type/rank etc.)

Ross Over a year ago

I'm using 1.8.0 - edited the question to include version and such.

francescalus Over a year ago

I'm in danger of not making sense (and I missed the version details in the question), but I'll try. There are times when having the array element corresponding to a dummy array is fine, and some times when not. An error should be given only in this latter case. With MPI, until all but the most recent standards of Fortran, MPI one didn't really want to pay attention to what the rules say...

Collectives™ on Stack Overflow

Compile-time warning to declare array as sequence

2 Answers 2

4 Comments

Issue with `is_contiguous`

Warning to Declare as `sequence`

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

2 Answers 2

4 Comments

Issue with is_contiguous

Warning to Declare as sequence

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related

Issue with `is_contiguous`

Warning to Declare as `sequence`