ports/openmpi
ports/openmpi
1
1
Форкнуть 0
Код Релизы Активность

Fixed to match Jeff S's changes to mpi-f90-interfaces.h.sh

Просмотр исходного кода 
This commit was SVN r9673.
Этот коммит содержится в:
Craig E Rasmussen 2006-04-20 21:17:09 +00:00
родитель 29219ee57d
Коммит 65d5e18e9b
2 изменённых файлов: 354 добавлений и 308 удалений
Показать статистику Скачать Patch файл Скачать Diff файл Показать все файлы Свернуть все файлы

515
ompi/mpi/f90/xml/chasm-mpi.i.f90.xsl
Просмотреть файл

@ -72,23 +72,10 @@
-->
<xsl:template name="defineFunctions">
<xsl:param name="module" select="@name"/>
<xsl:value-of select="$nl"/>
<xsl:for-each select="method">
<xsl:if test="@kind != 'No_F90'">
<xsl:value-of select="$nl"/>
<xsl:text>procedure='</xsl:text>
<xsl:value-of select="@name"/>
<xsl:text>'</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:value-of select="$nl"/>
<xsl:text>echo "interface ${procedure}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>echo</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:choose>
<xsl:when test="@template = 'yes'">
<xsl:call-template name="defineArrayFunctionBody"/>
@ -98,14 +85,6 @@
</xsl:otherwise>
</xsl:choose>
<xsl:text>echo "end interface ${procedure}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>echo</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>echo</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:value-of select="$nl"/>
</xsl:if>
</xsl:for-each>
@ -117,12 +96,23 @@
-->
<xsl:template name="defineFunctionBody">
<xsl:text>proc="${procedure}"</xsl:text>
<xsl:text>
#------------------------------------------------------------------------
output</xsl:text> <xsl:text>() {
if test "$output" = "0"; then
return 0
fi
procedure=$1
cat &lt;&lt;EOF
</xsl:text>
<xsl:text>subroutine ${procedure}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>echo " use mpi_kinds"</xsl:text>
<xsl:text> include 'mpif.h'</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="''"/>
@ -132,14 +122,39 @@
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text>echo " integer, intent(out) :: ierr"</xsl:text>
<xsl:text> integer, intent(out) :: ierr</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
</xsl:text>
end subroutine ${procedure}
EOF
}
start </xsl:text>
<xsl:choose>
<xsl:when test="@interface != ''">
<xsl:value-of select="@interface"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="@name"/>
</xsl:otherwise>
</xsl:choose>
<xsl:text> </xsl:text>
<xsl:call-template name="interface-size"/>
<xsl:text>
output </xsl:text> <xsl:value-of select="@name"/> <xsl:text>
end </xsl:text>
<xsl:choose>
<xsl:when test="@interface != ''">
<xsl:value-of select="@interface"/>
</xsl:when>
<xsl:otherwise>
<xsl:value-of select="@name"/>
</xsl:otherwise>
</xsl:choose>
<xsl:value-of select="$nl"/>
</xsl:template>
@ -149,21 +164,29 @@ echo
-->
<xsl:template name="defineArrayFunctionBody">
<xsl:text>rank=0</xsl:text>
<xsl:text>
#------------------------------------------------------------------------
output</xsl:text> <xsl:text>() {
if test "$output" = "0"; then
return 0
fi
procedure=$1
rank=$2
type=$4
proc="$1$2D$3"
cat &lt;&lt;EOF
</xsl:text>
<xsl:text>subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>for kind in $lkinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DL${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:text> include 'mpif.h'</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="ws" select="''"/>
<xsl:with-param name="void_type" select="'logical'"/>
<xsl:with-param name="void_kind" select="'INTEGER'"/>
<xsl:with-param name="has_dim" select="0"/>
@ -171,250 +194,100 @@ echo
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
<xsl:text> integer, intent(out) :: ierr</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
done
end subroutine ${proc}
</xsl:text>
EOF
}
<xsl:text>rank=0</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>for kind in $ikinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DI${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'integer'"/>
<xsl:with-param name="void_kind" select="'INTEGER'"/>
<xsl:with-param name="has_dim" select="0"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
start </xsl:text> <xsl:value-of select="@name"/> <xsl:text> </xsl:text>
<xsl:call-template name="interface-size"/>
<xsl:value-of select="$nl"/>
<xsl:text>
echo "end subroutine ${proc}"
echo
done
</xsl:text>
<xsl:text>rank=0</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>for kind in $rkinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DR${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'real'"/>
<xsl:with-param name="void_kind" select="'REAL'"/>
<xsl:with-param name="has_dim" select="0"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
done
</xsl:text>
<xsl:text>rank=0</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>for kind in $ckinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text>do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DC${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'complex'"/>
<xsl:with-param name="void_kind" select="'REAL'"/>
<xsl:with-param name="has_dim" select="0"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
done
</xsl:text>
<xsl:text>
for rank in $ranks
for rank in $allranks
do
case "$rank" in 1) dim=':' ; esac
case "$rank" in 2) dim=':,:' ; esac
case "$rank" in 3) dim=':,:,:' ; esac
case "$rank" in 4) dim=':,:,:,:' ; esac
case "$rank" in 5) dim=':,:,:,:,:' ; esac
case "$rank" in 6) dim=':,:,:,:,:,:' ; esac
case "$rank" in 7) dim=':,:,:,:,:,:,:' ; esac
case "$rank" in 0) dim='' ; esac
case "$rank" in 1) dim=', dimension(:)' ; esac
case "$rank" in 2) dim=', dimension(:,:)' ; esac
case "$rank" in 3) dim=', dimension(:,:,:)' ; esac
case "$rank" in 4) dim=', dimension(:,:,:,:)' ; esac
case "$rank" in 5) dim=', dimension(:,:,:,:,:)' ; esac
case "$rank" in 6) dim=', dimension(:,:,:,:,:,:)' ; esac
case "$rank" in 7) dim=', dimension(:,:,:,:,:,:,:)' ; esac
</xsl:text>
<xsl:text> for kind in $lkinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DL${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'logical'"/>
<xsl:with-param name="void_kind" select="'INTEGER'"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
output </xsl:text> <xsl:value-of select="@name"/>
<xsl:text> ${rank} CH "character${dim}"
output </xsl:text> <xsl:value-of select="@name"/>
<xsl:text> ${rank} L "logical${dim}"
for kind in $ikinds
do
output </xsl:text> <xsl:value-of select="@name"/>
<xsl:text> ${rank} I${kind} "integer*${kind}${dim}"
done
</xsl:text>
<xsl:text> for kind in $ikinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DI${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'integer'"/>
<xsl:with-param name="void_kind" select="'INTEGER'"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
for kind in $rkinds
do
output </xsl:text> <xsl:value-of select="@name"/>
<xsl:text> ${rank} R${kind} "real*${kind}${dim}"
done
</xsl:text>
<xsl:text> for kind in $rkinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DR${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'real'"/>
<xsl:with-param name="void_kind" select="'REAL'"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
for kind in $ckinds
do
output </xsl:text> <xsl:value-of select="@name"/>
<xsl:text> ${rank} C${kind} "complex*${kind}${dim}"
done
</xsl:text>
<xsl:text> for kind in $ckinds</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> do</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> proc="${procedure}${rank}DC${kind}"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo "subroutine ${proc}(</xsl:text>
<xsl:call-template name="arg-list"/> <xsl:text>)"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:text> echo " use mpi_kinds"</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="decl-construct-list">
<xsl:with-param name="ws" select="' '"/>
<xsl:with-param name="void_type" select="'complex'"/>
<xsl:with-param name="void_kind" select="'REAL'"/>
</xsl:call-template>
<xsl:for-each select="return[1]">
<xsl:if test="@name = 'ierr'">
<xsl:text> echo " integer, intent(out) :: ierr"</xsl:text>
</xsl:if>
</xsl:for-each>
<xsl:text>
echo "end subroutine ${proc}"
echo
done
echo
done
echo
</xsl:text>
end </xsl:text>
<xsl:value-of select="@name"/>
<xsl:value-of select="$nl"/>
</xsl:template>
<!--
- interface-size <method>
-->
<xsl:template name="interface-size">
<xsl:variable name="count">
<xsl:call-template name="choice-count"/>
</xsl:variable>
<xsl:choose>
<!-- special cases-->
<xsl:when test="@name = 'MPI_Alloc_mem'">
<xsl:text>medium</xsl:text>
</xsl:when>
<xsl:when test="@name = 'MPI_SIZEOF'">
<xsl:text>trivial</xsl:text>
</xsl:when>
<!-- end special cases-->
<xsl:when test="$count = ''">
<xsl:text>small</xsl:text>
</xsl:when>
<xsl:when test="$count = '1'">
<xsl:text>medium</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>large</xsl:text>
</xsl:otherwise>
</xsl:choose>
</xsl:template>
<!--
- choice-count <method>
-->
<xsl:template name="choice-count">
<xsl:for-each select="arg">
<xsl:if test="type/@idl = 'choice'">
<xsl:text>1</xsl:text>
</xsl:if>
</xsl:for-each>
</xsl:template>
@ -473,7 +346,7 @@ echo
<xsl:param name="has_dim" select="1"/>
<xsl:value-of select="$ws"/>
<xsl:text>echo " </xsl:text>
<xsl:text> </xsl:text>
<xsl:for-each select="type[1]">
<xsl:call-template name="decl-type-spec">
<xsl:with-param name="void_type" select="$void_type"/>
@ -484,7 +357,7 @@ echo
<xsl:for-each select="type[1]">
<xsl:call-template name="decl-type-intent"/>
</xsl:for-each>
<xsl:value-of select="concat(' :: ', @name, '&quot;', $nl)"/>
<xsl:value-of select="concat(' :: ', @name, $nl)"/>
</xsl:template>
@ -579,13 +452,7 @@ echo
<xsl:when test="@kind = 'void'">
<xsl:choose>
<xsl:when test="../../../../@template = 'yes'">
<xsl:value-of select="$void_type"/>
<xsl:text>(kind=MPI_</xsl:text>
<xsl:value-of select="$void_kind"/>
<xsl:text>${kind}_KIND)</xsl:text>
<xsl:if test="$has_dim">
<xsl:text>, dimension(${dim})</xsl:text>
</xsl:if>
<xsl:text>${type}</xsl:text>
</xsl:when>
<xsl:otherwise>
<xsl:text>integer</xsl:text>
@ -641,6 +508,9 @@ echo
</xsl:when>
<xsl:when test="@kind = 'usertype'">
<xsl:choose>
<xsl:when test="@usertype = 'default_integer'">
<xsl:text>integer</xsl:text>
</xsl:when>
<xsl:when test="@usertype = 'MPI_Aint'">
<xsl:text>integer(kind=MPI_ADDRESS_KIND)</xsl:text>
</xsl:when>
@ -648,7 +518,7 @@ echo
<xsl:text>integer(kind=MPI_OFFSET_KIND)</xsl:text>
</xsl:when>
<xsl:when test="@usertype = 'MPI_Status'">
<xsl:text>integer(MPI_STATUS_SIZE)</xsl:text>
<xsl:text>integer, dimension(MPI_STATUS_SIZE)</xsl:text>
</xsl:when>
<xsl:when test="@usertype = 'MPI_Comm_errhandler_fn'">
<xsl:text>external</xsl:text>
@ -722,16 +592,89 @@ echo
</xsl:template>
<!--
- copyright: print copyright
-->
<xsl:template name="copyright">
<xsl:text>
#
# Copyright (c) 2004-2006 The Trustees of Indiana University and Indiana
# University Research and Technology
# Corporation. All rights reserved.
# Copyright (c) 2004-2006 The Regents of the University of California.
# All rights reserved.
# Copyright (c) 2006 Cisco Systems, Inc. All rights reserved.
# $COPYRIGHT$
#
# Additional copyrights may follow
#
# $HEADER$
#
</xsl:text>
</xsl:template>
<!--
- info: print information about file
-->
<xsl:template name="info">
<xsl:text>
# Do a little error checking
if test ! -f fortran_kinds.sh; then
echo "ERROR: Cannot find fortran_kinds.sh" >&amp;2
exit 1
elif test -z fortran_kinds.sh; then
echo "ERROR: fortran_kinds.sh appears to be empty!" >&amp;2
exit 1
fi
# Read in the KIND information
. fortran_kinds.sh
# Setup
output=1
allranks="0 $ranks"
#------------------------------------------------------------------------
# Helper functions
start() {
check_size $2
if test "$output" = "1"; then
echo "interface $1"
fi
}
end() {
if test "$output" = "1"; then
cat &lt;&lt;EOF
end interface $1
EOF
fi
}
</xsl:text>
</xsl:template>
<!--
- openFile: print file header information
-->
<xsl:template name="openFile">
<xsl:param name="filename" select="''"/>
<xsl:text>#! /bin/sh</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:value-of select="$nl"/>
<xsl:text>. fortran_kinds.sh</xsl:text>
<xsl:value-of select="$nl"/>
<xsl:call-template name="copyright"/>
<xsl:call-template name="info"/>
</xsl:template>

147
ompi/mpi/f90/xml/mpi.h.xml
Просмотреть файл

@ -377,7 +377,7 @@
- there is no way to alloc memory in C for Fortran arrays
- see MPI_Free_mem
-->
<method name="MPI_Alloc_mem" kind="No_F90">
<method name="MPI_Alloc_mem" kind="final">
<!-- ARGUMENT : size -->
<arg name="size" intent="in">
@ -1953,7 +1953,7 @@
<method name="MPI_Comm_set_attr" kind="final">
<!-- ARGUMENT : comm -->
<arg name="comm" intent="in">
<arg name="comm" intent="inout">
<type kind="usertype" usertype="MPI_Comm" >
</type>
</arg>
@ -4624,11 +4624,11 @@
<!--
- METHOD: int MPI_Free_mem(void *) C
-->
<method name="MPI_Free_mem" kind="No_F90" template="yes">
<method name="MPI_Free_mem" kind="final" template="yes">
<!-- ARGUMENT : base -->
<arg name="base" intent="in">
<type kind="ptr">
<type kind="ptr" idl="choice">
<indirect depth="1" kind="pointer">
<type kind="void" >
</type>
@ -4862,11 +4862,11 @@
<!--
- METHOD: int MPI_Get_address(void *, MPI_Aint *) C
-->
<method name="MPI_Get_address" kind="No_F90" template="yes">
<method name="MPI_Get_address" kind="final" template="yes">
<!-- ARGUMENT : location -->
<arg name="location" intent="in">
<type kind="ptr" >
<type kind="ptr" idl="choice">
<indirect depth="1" kind="pointer">
<type kind="void" >
</type>
@ -8541,7 +8541,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="count"/>
</array>
</type>
</arg>
@ -8560,8 +8560,8 @@
<arg name="array_of_statuses" intent="inout">
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Status"/>
<dimension extent="*"/>
<type kind="int" ikind="int"/>
<dimension extent="count, MPI_STATUS_SIZE"/>
</array>
</type>
</arg>
@ -8589,7 +8589,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="count"/>
</array>
</type>
</arg>
@ -8647,7 +8647,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="incount"/>
</array>
</type>
</arg>
@ -8676,8 +8676,8 @@
<arg name="array_of_statuses" intent="inout">
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Status"/>
<dimension extent="*"/>
<type kind="int" ikind="int"/>
<dimension extent="incount, MPI_STATUS_SIZE"/>
</array>
</type>
</arg>
@ -10372,7 +10372,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="count"/>
</array>
</type>
</arg>
@ -10381,8 +10381,8 @@
<arg name="array_of_statuses" intent="inout">
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Status"/>
<dimension extent="*"/>
<type kind="int" ikind="int"/>
<dimension extent="count, MPI_STATUS_SIZE"/>
</array>
</type>
</arg>
@ -10410,7 +10410,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="count"/>
</array>
</type>
</arg>
@ -10458,7 +10458,7 @@
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Request"/>
<dimension extent="*"/>
<dimension extent="incount"/>
</array>
</type>
</arg>
@ -10487,8 +10487,8 @@
<arg name="array_of_statuses" intent="inout">
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Status"/>
<dimension extent="*"/>
<type kind="int" ikind="int"/>
<dimension extent="incount, MPI_STATUS_SIZE"/>
</array>
</type>
</arg>
@ -11607,8 +11607,20 @@
<!--
- METHOD: int MPI_Comm_spawn_multiple(int, char **, char ***, int *, MPI_Info *, int, MPI_Comm, MPI_Comm *, int *) C
#
# The SPAWN_MULTIPLE interface has a nice compile-time check to ensure
# that the "count" parameter matches the dimension of the other
# parameters. If the constant MPI_ARGVS_NULL is a character array of
# some kind, there is no guarantee that the count value provided by
# the application will match the dimension of MPI_ARGVS_NULL, which
# could therefore result in a[n erroneous] compile-time error. As
# such, it is simpler to just make MPI_ARGVS_NULL a wholly different
# type (e.g., integer) that matches an entirely different interface
# function.
#
-->
<method name="MPI_Comm_spawn_multiple" kind="final">
<method name="MPI_Comm_spawn_multipleN" kind="final"
interface="MPI_Comm_spawn_multiple">
<!-- ARGUMENT : count -->
<arg name="count" intent="in">
@ -11698,7 +11710,98 @@
</return>
</method>
<!--
- METHOD: int MPI_Comm_spawn_multiple(int, char **, char ***, int *, MPI_Info *, int, MPI_Comm, MPI_Comm *, int *) C
#
# Now we do the MPI_ARGVS_NULL variant - note the different type for
# the array_of_argv argument from the previous version
#
-->
<method name="MPI_Comm_spawn_multipleAN" kind="final"
interface="MPI_Comm_spawn_multiple">
<!-- ARGUMENT : count -->
<arg name="count" intent="in">
<type kind="int" ikind="int" >
</type>
</arg>
<!-- ARGUMENT : array_of_commands -->
<arg name="array_of_commands" intent="in">
<type kind="array" idl="MPI_ARGV">
<array lang="c" rank="2">
<type kind="int" ikind="char"/>
<dimension extent="*"/>
<dimension extent="*"/>
</array>
</type>
</arg>
<!-- ARGUMENT : array_of_argv -->
<arg name="array_of_argv" intent="in">
<type kind="int" ikind="int">
</type>
</arg>
<!-- ARGUMENT : array_of_maxprocs -->
<arg name="array_of_maxprocs" intent="in">
<type kind="array">
<array lang="c" rank="1">
<type kind="int" ikind="int"/>
<dimension extent="*"/>
</array>
</type>
</arg>
<!-- ARGUMENT : array_of_info -->
<arg name="array_of_info" intent="in">
<type kind="array">
<array lang="c" rank="1">
<type kind="usertype" usertype="MPI_Info"/>
<dimension extent="*"/>
</array>
</type>
</arg>
<!-- ARGUMENT : root -->
<arg name="root" intent="in">
<type kind="int" ikind="int" >
</type>
</arg>
<!-- ARGUMENT : comm -->
<arg name="comm" intent="in">
<type kind="usertype" usertype="MPI_Comm" >
</type>
</arg>
<!-- ARGUMENT : intercomm -->
<arg name="intercomm" intent="out">
<type kind="ptr" >
<indirect depth="1" kind="pointer">
<type kind="usertype" usertype="MPI_Comm" >
</type>
</indirect>
</type>
</arg>
<!-- ARGUMENT : array_of_errcodes -->
<arg name="array_of_errcodes" intent="out">
<type kind="array">
<array lang="c" rank="1">
<type kind="int" ikind="int"/>
<dimension extent="*"/>
</array>
</type>
</arg>
<!-- return type (name=int) -->
<return name="ierr">
<type kind="int" ikind="int" >
</type>
</return>
</method>
</scope>
</library>