mpi-f90-interfaces.h.sh

MPI stands for the Message Passing Interface. Written by the MPI Forum (a large committee comprising

start MPI_Alltoallv large

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_12 MPI_Alltoallv ${rank} CH "character${dim}"
  output_12 MPI_Alltoallv ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_12 MPI_Alltoallv ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_12 MPI_Alltoallv ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_12 MPI_Alltoallv ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Alltoallv

#------------------------------------------------------------------------

output_13() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(sendbuf, sendcounts, sdispls, sendtypes, recvbuf, &
        recvcounts, rdispls, recvtypes, comm, ierr)
  ${type}, intent(in) :: sendbuf
  integer, dimension(*), intent(in) :: sendcounts
  integer, dimension(*), intent(in) :: sdispls
  integer, dimension(*), intent(in) :: sendtypes
  ${type}, intent(out) :: recvbuf
  integer, dimension(*), intent(in) :: recvcounts
  integer, dimension(*), intent(in) :: rdispls
  integer, dimension(*), intent(in) :: recvtypes
  integer, intent(in) :: comm
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Alltoallw large

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_13 MPI_Alltoallw ${rank} CH "character${dim}"
  output_13 MPI_Alltoallw ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_13 MPI_Alltoallw ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_13 MPI_Alltoallw ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_13 MPI_Alltoallw ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Alltoallw

#------------------------------------------------------------------------

output_14() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, keyval, ierr)
  integer, intent(in) :: comm
  integer, intent(in) :: keyval
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Attr_delete small
output_14 MPI_Attr_delete
end MPI_Attr_delete

#------------------------------------------------------------------------

output_15() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, keyval, attribute_val, flag, ierr)
  integer, intent(in) :: comm
  integer, intent(in) :: keyval
  integer, intent(out) :: attribute_val
  logical, intent(out) :: flag
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Attr_get small
output_15 MPI_Attr_get
end MPI_Attr_get

#------------------------------------------------------------------------

output_16() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, keyval, attribute_val, ierr)
  integer, intent(in) :: comm
  integer, intent(in) :: keyval
  integer, intent(in) :: attribute_val
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Attr_put small
output_16 MPI_Attr_put
end MPI_Attr_put

#------------------------------------------------------------------------

output_17() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, ierr)
  integer, intent(in) :: comm
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Barrier small
output_17 MPI_Barrier
end MPI_Barrier

#------------------------------------------------------------------------

output_18() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(buffer, count, datatype, root, comm&
        , ierr)
  ${type}, intent(in) :: buffer
  integer, intent(in) :: count
  integer, intent(in) :: datatype
  integer, intent(in) :: root
  integer, intent(in) :: comm
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Bcast medium

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_18 MPI_Bcast ${rank} CH "character${dim}"
  output_18 MPI_Bcast ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_18 MPI_Bcast ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_18 MPI_Bcast ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_18 MPI_Bcast ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Bcast

#------------------------------------------------------------------------

output_19() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(buf, count, datatype, dest, tag, &
        comm, ierr)
  ${type}, intent(in) :: buf
  integer, intent(in) :: count
  integer, intent(in) :: datatype
  integer, intent(in) :: dest
  integer, intent(in) :: tag
  integer, intent(in) :: comm
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Bsend medium

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_19 MPI_Bsend ${rank} CH "character${dim}"
  output_19 MPI_Bsend ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_19 MPI_Bsend ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_19 MPI_Bsend ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_19 MPI_Bsend ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Bsend

#------------------------------------------------------------------------

output_20() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(buf, count, datatype, dest, tag, &
        comm, request, ierr)
  ${type}, intent(in) :: buf
  integer, intent(in) :: count
  integer, intent(in) :: datatype
  integer, intent(in) :: dest
  integer, intent(in) :: tag
  integer, intent(in) :: comm
  integer, intent(out) :: request
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Bsend_init medium

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_20 MPI_Bsend_init ${rank} CH "character${dim}"
  output_20 MPI_Bsend_init ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_20 MPI_Bsend_init ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_20 MPI_Bsend_init ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_20 MPI_Bsend_init ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Bsend_init

#------------------------------------------------------------------------

output_21() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(buffer, size, ierr)
  ${type}, intent(in) :: buffer
  integer, intent(in) :: size
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Buffer_attach medium

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_21 MPI_Buffer_attach ${rank} CH "character${dim}"
  output_21 MPI_Buffer_attach ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_21 MPI_Buffer_attach ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_21 MPI_Buffer_attach ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_21 MPI_Buffer_attach ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Buffer_attach

#------------------------------------------------------------------------

output_22() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    rank=$2
    type=$4
    proc="$1$2D$3"
    cat <<EOF

subroutine ${proc}(buffer, size, ierr)
  ${type}, intent(out) :: buffer
  integer, intent(out) :: size
  integer, intent(out) :: ierr
end subroutine ${proc}

EOF
}

start MPI_Buffer_detach medium

for rank in $allranks
do
  case "$rank" in  0)  dim=''  ;  esac
  case "$rank" in  1)  dim=', dimension(*)'  ;  esac
  case "$rank" in  2)  dim=', dimension(1,*)'  ;  esac
  case "$rank" in  3)  dim=', dimension(1,1,*)'  ;  esac
  case "$rank" in  4)  dim=', dimension(1,1,1,*)'  ;  esac
  case "$rank" in  5)  dim=', dimension(1,1,1,1,*)'  ;  esac
  case "$rank" in  6)  dim=', dimension(1,1,1,1,1,*)'  ;  esac
  case "$rank" in  7)  dim=', dimension(1,1,1,1,1,1,*)'  ;  esac

  output_22 MPI_Buffer_detach ${rank} CH "character${dim}"
  output_22 MPI_Buffer_detach ${rank} L "logical${dim}"
  for kind in $ikinds
  do
    output_22 MPI_Buffer_detach ${rank} I${kind} "integer*${kind}${dim}"
  done
  for kind in $rkinds
  do
    output_22 MPI_Buffer_detach ${rank} R${kind} "real*${kind}${dim}"
  done
  for kind in $ckinds
  do
    output_22 MPI_Buffer_detach ${rank} C${kind} "complex*${kind}${dim}"
  done
done
end MPI_Buffer_detach

#------------------------------------------------------------------------

output_23() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(request, ierr)
  integer, intent(in) :: request
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Cancel small
output_23 MPI_Cancel
end MPI_Cancel

#------------------------------------------------------------------------

output_24() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, rank, maxdims, coords, ierr)
  integer, intent(in) :: comm
  integer, intent(in) :: rank
  integer, intent(in) :: maxdims
  integer, dimension(*), intent(out) :: coords
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Cart_coords small
output_24 MPI_Cart_coords
end MPI_Cart_coords

#------------------------------------------------------------------------

output_25() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(old_comm, ndims, dims, periods, reorder, &
        comm_cart, ierr)
  integer, intent(in) :: old_comm
  integer, intent(in) :: ndims
  integer, dimension(*), intent(in) :: dims
  integer, dimension(*), intent(in) :: periods
  integer, intent(in) :: reorder
  integer, intent(out) :: comm_cart
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Cart_create small
output_25 MPI_Cart_create
end MPI_Cart_create

#------------------------------------------------------------------------

output_26() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, maxdims, dims, periods, coords&
        , ierr)
  integer, intent(in) :: comm
  integer, intent(in) :: maxdims
  integer, dimension(*), intent(out) :: dims
  integer, dimension(*), intent(out) :: periods
  integer, dimension(*), intent(out) :: coords
  integer, intent(out) :: ierr
end subroutine ${procedure}

EOF
}

start MPI_Cart_get small
output_26 MPI_Cart_get
end MPI_Cart_get

#------------------------------------------------------------------------

output_27() {
    if test "$output" = "0"; then
        return 0
    fi

    procedure=$1
    cat <<EOF

subroutine ${procedure}(comm, ndims, dims, periods, newrank&
        , ierr)