From e05f6ce3da9b17ce0385c4ebb97559a0a2eabdcb Mon Sep 17 00:00:00 2001 From: Gilles Gouaillardet Date: Sun, 18 Aug 2019 19:27:01 +0900 Subject: [PATCH] fortran/use-mpi-f08: add CFI support for one sided operations --- .../fortran/use-mpi-f08/accumulate_f08.F90 | 2 +- .../bindings/mpi-f-interfaces-bind.h.in | 4090 +++++++++++++++++ .../use-mpi-f08/compare_and_swap_f08.F90 | 4 +- .../fortran/use-mpi-f08/fetch_and_op_f08.F90 | 4 +- .../use-mpi-f08/get_accumulate_f08.F90 | 4 +- ompi/mpi/fortran/use-mpi-f08/get_f08.F90 | 2 +- .../use-mpi-f08/mod/mpi-f08-interfaces.h.in | 56 +- .../use-mpi-f08/mod/mpi-f08-rename.h.in | 967 ++++ ompi/mpi/fortran/use-mpi-f08/put_f08.F90 | 2 +- .../fortran/use-mpi-f08/raccumulate_f08.F90 | 2 +- .../use-mpi-f08/rget_accumulate_f08.F90 | 4 +- ompi/mpi/fortran/use-mpi-f08/rget_f08.F90 | 2 +- ompi/mpi/fortran/use-mpi-f08/rput_f08.F90 | 2 +- .../fortran/use-mpi-f08/ts/accumulate_ts.c | 64 + .../use-mpi-f08/ts/compare_and_swap_ts.c | 67 + .../fortran/use-mpi-f08/ts/fetch_and_op_ts.c | 62 + .../use-mpi-f08/ts/get_accumulate_ts.c | 84 + ompi/mpi/fortran/use-mpi-f08/ts/get_ts.c | 60 + ompi/mpi/fortran/use-mpi-f08/ts/put_ts.c | 60 + .../fortran/use-mpi-f08/ts/raccumulate_ts.c | 73 + .../use-mpi-f08/ts/rget_accumulate_ts.c | 91 + ompi/mpi/fortran/use-mpi-f08/ts/rget_ts.c | 69 + ompi/mpi/fortran/use-mpi-f08/ts/rput_ts.c | 69 + .../fortran/use-mpi-f08/ts/win_attach_ts.c | 33 + .../fortran/use-mpi-f08/ts/win_create_ts.c | 55 + .../fortran/use-mpi-f08/ts/win_detach_ts.c | 33 + .../fortran/use-mpi-f08/win_attach_f08.F90 | 2 +- .../fortran/use-mpi-f08/win_create_f08.F90 | 2 +- .../fortran/use-mpi-f08/win_detach_f08.F90 | 2 +- 29 files changed, 5922 insertions(+), 45 deletions(-) create mode 100644 ompi/mpi/fortran/use-mpi-f08/bindings/mpi-f-interfaces-bind.h.in create mode 100644 ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h.in create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/accumulate_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/compare_and_swap_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/fetch_and_op_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/get_accumulate_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/get_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/put_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/raccumulate_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/rget_accumulate_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/rget_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/rput_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/win_attach_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/win_create_ts.c create mode 100644 ompi/mpi/fortran/use-mpi-f08/ts/win_detach_ts.c diff --git a/ompi/mpi/fortran/use-mpi-f08/accumulate_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/accumulate_f08.F90 index cf5f9ada671..913407ffaba 100644 --- a/ompi/mpi/fortran/use-mpi-f08/accumulate_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/accumulate_f08.F90 @@ -17,7 +17,7 @@ subroutine MPI_Accumulate_f08(origin_addr,origin_count,origin_datatype,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_accumulate_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/bindings/mpi-f-interfaces-bind.h.in b/ompi/mpi/fortran/use-mpi-f08/bindings/mpi-f-interfaces-bind.h.in new file mode 100644 index 00000000000..ee588c40b2a --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/bindings/mpi-f-interfaces-bind.h.in @@ -0,0 +1,4090 @@ +! -*- f90 -*- +! +! Copyright (c) 2009-2022 Cisco Systems, Inc. All rights reserved +! Copyright (c) 2009-2012 Los Alamos National Security, LLC. +! All rights reserved. +! Copyright (c) 2012 The University of Tennessee and The University +! of Tennessee Research Foundation. All rights +! reserved. +! Copyright (c) 2012 Inria. All rights reserved. +! Copyright (c) 2015-2020 Research Organization for Information Science +! and Technology (RIST). All rights reserved. +! Copyright (c) 2019 Triad National Security, LLC. All rights +! reserved. +! Copyright (c) 2021 Bull S.A.S. All rights reserved. +! Copyright (c) 2021-2022 Triad National Security, LLC. All rights +! reserved. +! $COPYRIGHT$ +! +! This file provides the interface specifications for the MPI Fortran +! API bindings. It effectively maps between public names ("MPI_Init") +! and the back-end OMPI implementation subroutine name (e.g., +! "ompi_init_f"). +! + +#include "ompi/mpi/fortran/configure-fortran-output.h" + +! +! Most of the "wrapper" subroutines in the mpi_f08 module (i.e., all +! the ones prototyped in this file) are simple routines that simply +! invoke a back-end ompi_*_f() subroutine, which is BIND(C)-bound to a +! back-end C function. Easy-peasy. +! +! However, a bunch of MPI Fortran subroutines use LOGICAL dummy +! parameters, and Fortran disallows passing LOGICAL parameters to +! BIND(C) routines (because the .TRUE. and .FALSE. values are not +! standardized (!)). Hence, for these +! subroutines-with-LOGICAL-params, we have to be creative on how to +! invoke the back-end ompi_*_f() C function. There are 2 cases: + +! 1. If the Fortran interface has a LOGICAL parameter and no +! TYPE(MPI_Status) parameter, the individual wrapper implementation +! files (e.g., finalized_f08.F90) use the "mpi" module to get a +! interface for the subroutine and call the PMPI_* name of the +! function, which then invokes the corresponding function in the +! ompi/mpi/fortran/mpif-h directory. +! +! This is a bit of a hack: the "mpi" module will provide the right +! Fortran interface so that the compiler can verify that we're passing +! the right types (e.g., convert MPI handles from comm to +! comm%MPI_VAL). But here's the hack part: when we pass *unbounded +! arrays* of handles (e.g., the sendtypes and recvtypes arrays +! MPI_Alltoallw), we declare that the corresponding ompi_*_f() +! subroutine takes a *scalar*, and then we pass sendtypes(0)%MPI_VAL. +! +! >>>THIS IS A LIE!<<< We're passing a scalar to something that +! expects an array. +! +! However, remember that Fortran passes by reference. So the compiler +! will pass a pointer to sendtypes(0)%MPI_VAL (i.e., the first integer +! in the array). And since the mpi_f08 handles were cleverly designed +! to be exactly equivalent to a single INTEGER, an array of mpi_f08 +! handles is exactly equivalent to an array of INTEGERS. So passing +! an address to the first MPI_VAL is exactly the same as passing an +! array of INTEGERS. +! +! Specifically: the back-end C function (in *.c files in +! ompi/mpi/fortran/mpif-h) gets an (MPI_Fint*), and it's all good. +! +! The key here is that there is a disconnect between Fortran and C: +! we're telling the Fortran compiler what the C interface is, and +! we're lying. But just a little bit. No one gets hurt. +! +! Yes, this is a total hack. But Craig Rasumussen tells me that this +! is actually quite a common hack in the Fortran developer world, so +! we shouldn't feel bad about using it. Shrug. +! +! 2. If the Fortran interface has both LOGICAL and TYPE(MPI_Status) +! parameters, then we have to do even more tricks than we described +! above. :-( +! +! The problem occurs because in the mpi_f08 module, an MPI_Status is +! TYPE(MPI_Status), but in the mpi module, it's INTEGER, +! DIMENSION(MPI_STATUS_SIZE). Just like MPI handles, TYPE(MPI_Status) +! was cleverly designed so that it can be identical (in terms of a +! memory map) to INTEGER, DIMENSION(MPI_STATUS_SIZE). So we just have +! to fool the compiler into accepting it (it's the same C<-->Fortran +! disconnect from #1). +! +! So in this case, we actually don't "use mpi" at all -- we just add +! an "interface" block for the PMPI_* subroutine that we want to call. +! And we lie in that interface block, saying that the status argument +! is TYPE(MPI_Status) (rather than an INTEGER, +! DIMENSION(MPI_STATUS_SIZE), which is what it *really* is) -- i.e., +! the same type that we already have. +! +! For the C programmers reading this, this is very much analogous to +! something like this: +! +! $ cat header.h +! void foo(int *param); +! $ cat source.c +! #include "header.h" +! // Pretend that we *know* somehow that param will point to exactly +! // sizeof(int) bytes. +! void bar(char *param) { +! foo(param); // <-- This generates a compiler warning +! } +! +! To fix the compiler warning, instead of including "header.h", we +! just put a byte-equivalent prototype in source.c: +! +! $ cat source.c +! void foo(char *param); +! void bar(char *param) { +! foo(param); +! } +! +! And now it compiles without warning. +! +! The main difference here is that in Fortran, it is an error -- not a +! warning. +! +! Again, we're making the Fortran compiler happy, but we're lying +! because we know the back-end memory representation of the two types +! is the same. +! +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +! +! Wasn't that simple? Here's the list of subroutines that are not +! prototyped in this file because they fall into case #1 or #2, above. +! +! Case #1: +! MPI_Cart_create +! MPI_Cart_get +! MPI_Cart_map +! MPI_Cart_sub +! MPI_Comm_get_attr +! MPI_Comm_test_inter +! MPI_Dist_graph_create +! MPI_Dist_graph_create_adjacent +! MPI_Dist_graph_neighbors_count +! MPI_File_get_atomicity +! MPI_File_set_atomicity +! MPI_Finalized +! MPI_Graph_create +! MPI_Info_get +! MPI_Info_get_valuelen +! MPI_Initialized +! MPI_Intercomm_merge +! MPI_Is_thread_main +! MPI_Op_commutative +! MPI_Op_create +! MPI_Parrived +! MPI_Type_get_attr +! MPI_Win_get_attr +! MPI_Win_test +! +! Case #2: +! MPI_Iprobe +! MPI_Improbe +! MPI_Request_get_status +! MPI_Status_set_cancelled +! MPI_Test +! MPI_Testall +! MPI_Testany +! MPI_Testsome +! MPI_Test_cancelled +! + +interface + +subroutine ompi_bsend_f(buf,count,datatype,dest,tag,comm,ierror) & + BIND(C, name="ompi_bsend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_bsend_f + +subroutine ompi_bsend_init_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_bsend_init_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_bsend_init_f + +subroutine ompi_buffer_attach_f(buffer,size,ierror) & + BIND(C, name="ompi_buffer_attach_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buffer + INTEGER, INTENT(IN) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_buffer_attach_f + +! Note that we have an F08-specific C implementation function for +! MPI_BUFFER_DETACH (i.e., it is different than the mpif.h / mpi +! module C implementation function). +subroutine ompi_buffer_detach_f(buffer_addr,size,ierror) & + BIND(C, name="ompi_buffer_detach_f08") + USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_PTR + implicit none + TYPE(C_PTR), INTENT(OUT) :: buffer_addr + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_buffer_detach_f + +subroutine ompi_cancel_f(request,ierror) & + BIND(C, name="ompi_cancel_f") + implicit none + INTEGER, INTENT(IN) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_cancel_f + +subroutine ompi_get_count_f(status,datatype,count,ierror) & + BIND(C, name="ompi_get_count_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + TYPE(MPI_Status), INTENT(IN) :: status + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: count + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_count_f + +subroutine ompi_ibsend_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_ibsend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ibsend_f + +subroutine ompi_irecv_f(buf,count,datatype,source,tag,comm,request,ierror) & + BIND(C, name="ompi_irecv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, source, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_irecv_f + +subroutine ompi_irsend_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_irsend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_irsend_f + +subroutine ompi_isend_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_isend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_isend_f + +subroutine ompi_isendrecv_f(sendbuf,sendcount,sendtype,dest,sendtag,recvbuf, & + recvcount,recvtype,source,recvtag,comm,request,ierror) & + BIND(C, name="ompi_isendrecv_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, dest, sendtag, recvcount, source, recvtag + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_isendrecv_f + +subroutine ompi_isendrecv_replace_f(buf,count,datatype,dest,sendtag,source, & + recvtag,comm,request,ierror) & + BIND(C, name="ompi_isendrecv_replace_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count, dest, sendtag, source, recvtag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_isendrecv_replace_f + +subroutine ompi_issend_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_issend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_issend_f + +subroutine ompi_psend_init_f(buf,partitions,count,datatype,dest,tag,comm,info,request,ierror) & + BIND(C, name="ompi_psend_init_f") + use :: mpi_f08_types, only : MPI_COUNT_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: partitions, dest, tag + INTEGER(KIND=MPI_COUNT_KIND), INTENT(IN):: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_psend_init_f + +subroutine ompi_precv_init_f(buf,partitions,count,datatype,dest,tag,comm,info,request,ierror) & + BIND(C, name="ompi_precv_init_f") + use :: mpi_f08_types, only : MPI_COUNT_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: partitions, dest, tag + INTEGER(KIND=MPI_COUNT_KIND), INTENT(IN):: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_precv_init_f + +subroutine ompi_pready_f(partition,request,ierror) & + BIND(C, name="ompi_pready_f") + implicit none + INTEGER, INTENT(IN) :: partition + INTEGER, INTENT(IN) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_pready_f + +subroutine ompi_pready_list_f(length,partitions,request,ierror) & + BIND(C, name="ompi_pready_list_f") + implicit none + INTEGER, INTENT(IN) :: length + INTEGER, INTENT(IN) :: partitions(*) + INTEGER, INTENT(IN) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_pready_list_f + +subroutine ompi_pready_range_f(partition_low,partition_high,request,ierror) & + BIND(C, name="ompi_pready_range_f") + implicit none + INTEGER, INTENT(IN) :: partition_low, partition_high + INTEGER, INTENT(IN) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_pready_range_f + +subroutine ompi_probe_f(source,tag,comm,status,ierror) & + BIND(C, name="ompi_probe_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: source, tag + INTEGER, INTENT(IN) :: comm + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_probe_f + +subroutine ompi_recv_f(buf,count,datatype,source,tag,comm,status,ierror) & + BIND(C, name="ompi_recv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Status + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count, source, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_recv_f + +subroutine ompi_recv_init_f(buf,count,datatype,source,tag,comm,request,ierror) & + BIND(C, name="ompi_recv_init_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, source, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_recv_init_f + +subroutine ompi_request_free_f(request,ierror) & + BIND(C, name="ompi_request_free_f") + implicit none + INTEGER, INTENT(INOUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_request_free_f + +subroutine ompi_rsend_f(buf,count,datatype,dest,tag,comm,ierror) & + BIND(C, name="ompi_rsend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_rsend_f + +subroutine ompi_rsend_init_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_rsend_init_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_rsend_init_f + +subroutine ompi_send_f(buf,count,datatype,dest,tag,comm,ierror) & + BIND(C, name="ompi_send_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_send_f + +subroutine ompi_sendrecv_f(sendbuf,sendcount,sendtype,dest,sendtag,recvbuf, & + recvcount,recvtype,source,recvtag,comm,status,ierror) & + BIND(C, name="ompi_sendrecv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Status + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, dest, sendtag, recvcount, source, recvtag + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_sendrecv_f + +subroutine ompi_sendrecv_replace_f(buf,count,datatype,dest,sendtag,source, & + recvtag,comm,status,ierror) & + BIND(C, name="ompi_sendrecv_replace_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Status + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count, dest, sendtag, source, recvtag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_sendrecv_replace_f + +subroutine ompi_send_init_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_send_init_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_send_init_f + +subroutine ompi_ssend_f(buf,count,datatype,dest,tag,comm,ierror) & + BIND(C, name="ompi_ssend_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ssend_f + +subroutine ompi_ssend_init_f(buf,count,datatype,dest,tag,comm,request,ierror) & + BIND(C, name="ompi_ssend_init_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count, dest, tag + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ssend_init_f + +subroutine ompi_start_f(request,ierror) & + BIND(C, name="ompi_start_f") + implicit none + INTEGER, INTENT(INOUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_start_f + +subroutine ompi_startall_f(count,array_of_requests,ierror) & + BIND(C, name="ompi_startall_f") + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(INOUT) :: array_of_requests(count) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_startall_f + +subroutine ompi_wait_f(request,status,ierror) & + BIND(C, name="ompi_wait_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(INOUT) :: request + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_wait_f + +subroutine ompi_waitall_f(count,array_of_requests,array_of_statuses,ierror) & + BIND(C, name="ompi_waitall_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(INOUT) :: array_of_requests(count) + TYPE(MPI_Status) :: array_of_statuses(*) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_waitall_f + +subroutine ompi_waitany_f(count,array_of_requests,index,status,ierror) & + BIND(C, name="ompi_waitany_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(INOUT) :: array_of_requests(count) + INTEGER, INTENT(OUT) :: index + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_waitany_f + +subroutine ompi_waitsome_f(incount,array_of_requests,outcount, & + array_of_indices,array_of_statuses,ierror) & + BIND(C, name="ompi_waitsome_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: incount + INTEGER, INTENT(INOUT) :: array_of_requests(incount) + INTEGER, INTENT(OUT) :: outcount + INTEGER, INTENT(OUT) :: array_of_indices(*) + TYPE(MPI_Status) :: array_of_statuses(*) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_waitsome_f + +subroutine ompi_get_address_f(location,address,ierror) & + BIND(C, name="ompi_get_address_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: location + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: address + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_address_f + +subroutine ompi_get_elements_f(status,datatype,count,ierror) & + BIND(C, name="ompi_get_elements_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + TYPE(MPI_Status), INTENT(IN) :: status + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: count + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_elements_f + +subroutine ompi_get_elements_x_f(status,datatype,count,ierror) & + BIND(C, name="ompi_get_elements_x_f") + use :: mpi_f08_types, only : MPI_Status, MPI_COUNT_KIND + implicit none + TYPE(MPI_Status), INTENT(IN) :: status + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_COUNT_KIND), INTENT(OUT) :: count + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_elements_x_f + +subroutine ompi_pack_f(inbuf,incount,datatype,outbuf,outsize, & + position,comm,ierror) & + BIND(C, name="ompi_pack_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: inbuf + OMPI_F08_IGNORE_TKR_TYPE :: outbuf + INTEGER, INTENT(IN) :: incount, outsize + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(INOUT) :: position + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_pack_f + +subroutine ompi_pack_external_f(datarep,inbuf,incount,datatype, & + outbuf,outsize,position,ierror,datarep_len) & + BIND(C, name="ompi_pack_external_@OMPI_F08_BINDINGS_EXTENSION@") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: datarep + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: inbuf + OMPI_F08_IGNORE_TKR_TYPE :: outbuf + INTEGER, INTENT(IN) :: incount + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: outsize + INTEGER(MPI_ADDRESS_KIND), INTENT(INOUT) :: position + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_pack_external_f + +subroutine ompi_pack_external_size_f(datarep,incount,datatype,size,ierror,datarep_len) & + BIND(C, name="ompi_pack_external_size_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: incount + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: datarep + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_pack_external_size_f + +subroutine ompi_pack_size_f(incount,datatype,comm,size,ierror) & + BIND(C, name="ompi_pack_size_f") + implicit none + INTEGER, INTENT(IN) :: incount + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_pack_size_f + +subroutine ompi_type_commit_f(datatype,ierror) & + BIND(C, name="ompi_type_commit_f") + implicit none + INTEGER, INTENT(INOUT) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_commit_f + +subroutine ompi_type_contiguous_f(count,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_contiguous_f") + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_contiguous_f + +subroutine ompi_type_create_darray_f(size,rank,ndims,& + array_of_gsizes,array_of_distribs,array_of_dargs,array_of_psizes,& + order,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_darray_f") + implicit none + INTEGER, INTENT(IN) :: size, rank, ndims, order + INTEGER, INTENT(IN) :: array_of_gsizes(ndims), array_of_distribs(ndims) + INTEGER, INTENT(IN) :: array_of_dargs(ndims), array_of_psizes(ndims) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_darray_f + +subroutine ompi_type_create_hindexed_f(count,array_of_blocklengths, & + array_of_displacements,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_hindexed_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: array_of_blocklengths(count) + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: array_of_displacements(count) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_hindexed_f + +subroutine ompi_type_create_hvector_f(count,blocklength,stride,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_hvector_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: count, blocklength + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: stride + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_hvector_f + +subroutine ompi_type_create_indexed_block_f(count,blocklength, & + array_of_displacements,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_indexed_block_f") + implicit none + INTEGER, INTENT(IN) :: count, blocklength + INTEGER, INTENT(IN) :: array_of_displacements(count) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_indexed_block_f + +subroutine ompi_type_create_hindexed_block_f(count,blocklength, & + array_of_displacements,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_hindexed_block_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: count, blocklength + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: array_of_displacements(count) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_hindexed_block_f + +subroutine ompi_type_create_resized_f(oldtype,lb,extent,newtype,ierror) & + BIND(C, name="ompi_type_create_resized_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: lb, extent + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_resized_f + +subroutine ompi_type_create_struct_f(count,array_of_blocklengths, & + array_of_displacements,array_of_types,newtype,ierror) & + BIND(C, name="ompi_type_create_struct_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: array_of_blocklengths(count) + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: array_of_displacements(count) + INTEGER, INTENT(IN) :: array_of_types(count) + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_struct_f + +subroutine ompi_type_create_subarray_f(ndims,array_of_sizes, & + array_of_subsizes,array_of_starts,order,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_create_subarray_f") + implicit none + INTEGER, INTENT(IN) :: ndims, order + INTEGER, INTENT(IN) :: array_of_sizes(ndims), array_of_subsizes(ndims), array_of_starts(ndims) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_subarray_f + +subroutine ompi_type_dup_f(oldtype,newtype,ierror) & + BIND(C, name="ompi_type_dup_f") + implicit none + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_dup_f + +subroutine ompi_type_free_f(datatype,ierror) & + BIND(C, name="ompi_type_free_f") + implicit none + INTEGER, INTENT(INOUT) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_free_f + +subroutine ompi_type_get_contents_f(datatype,max_integers,max_addresses, & + max_datatypes,array_of_integers,array_of_addresses, & + array_of_datatypes,ierror) & + BIND(C, name="ompi_type_get_contents_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: max_integers, max_addresses, max_datatypes + INTEGER, INTENT(OUT) :: array_of_integers(max_integers) + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: array_of_addresses(max_addresses) + INTEGER, INTENT(OUT) :: array_of_datatypes(max_datatypes) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_contents_f + +subroutine ompi_type_get_envelope_f(datatype,num_integers, & + num_addresses,num_datatypes,combiner,ierror) & + BIND(C, name="ompi_type_get_envelope_f") + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: num_integers, num_addresses, num_datatypes, combiner + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_envelope_f + +subroutine ompi_type_get_extent_f(datatype,lb,extent,ierror) & + BIND(C, name="ompi_type_get_extent_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: lb, extent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_extent_f + +subroutine ompi_type_get_extent_x_f(datatype,lb,extent,ierror) & + BIND(C, name="ompi_type_get_extent_x_f") + use :: mpi_f08_types, only : MPI_COUNT_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_COUNT_KIND), INTENT(OUT) :: lb, extent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_extent_x_f + +subroutine ompi_type_get_true_extent_f(datatype,true_lb,true_extent,ierror) & + BIND(C, name="ompi_type_get_true_extent_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: true_lb, true_extent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_true_extent_f + +subroutine ompi_type_get_true_extent_x_f(datatype,true_lb,true_extent,ierror) & + BIND(C, name="ompi_type_get_true_extent_x_f") + use :: mpi_f08_types, only : MPI_COUNT_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_COUNT_KIND), INTENT(OUT) :: true_lb, true_extent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_get_true_extent_x_f + +subroutine ompi_type_indexed_f(count,array_of_blocklengths, & + array_of_displacements,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_indexed_f") + implicit none + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: array_of_blocklengths(count), array_of_displacements(count) + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_indexed_f + +subroutine ompi_type_size_f(datatype,size,ierror) & + BIND(C, name="ompi_type_size_f") + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_size_f + +subroutine ompi_type_size_x_f(datatype,size,ierror) & + BIND(C, name="ompi_type_size_x_f") + use :: mpi_f08_types, only : MPI_COUNT_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_COUNT_KIND), INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_size_x_f + +subroutine ompi_type_vector_f(count,blocklength,stride,oldtype,newtype,ierror) & + BIND(C, name="ompi_type_vector_f") + implicit none + INTEGER, INTENT(IN) :: count, blocklength, stride + INTEGER, INTENT(IN) :: oldtype + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_vector_f + +subroutine ompi_unpack_f(inbuf,insize,position,outbuf,outcount, & + datatype,comm,ierror) & + BIND(C, name="ompi_unpack_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: inbuf + OMPI_F08_IGNORE_TKR_TYPE :: outbuf + INTEGER, INTENT(IN) :: insize, outcount + INTEGER, INTENT(INOUT) :: position + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_unpack_f + +subroutine ompi_unpack_external_f(datarep,inbuf,insize,position, & + outbuf,outcount,datatype,ierror,datarep_len) & + BIND(C, name="ompi_unpack_external_@OMPI_F08_BINDINGS_EXTENSION@") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: datarep + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: inbuf + OMPI_F08_IGNORE_TKR_TYPE :: outbuf + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: insize + INTEGER(MPI_ADDRESS_KIND), INTENT(INOUT) :: position + INTEGER, INTENT(IN) :: outcount + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_unpack_external_f + +subroutine ompi_allgather_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,ierror) & + BIND(C, name="ompi_allgather_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allgather_f + +subroutine ompi_iallgather_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,request,ierror) & + BIND(C, name="ompi_iallgather_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iallgather_f + +subroutine ompi_allgather_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_allgather_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allgather_init_f + +subroutine ompi_allgatherv_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,comm,ierror) & + BIND(C, name="ompi_allgatherv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allgatherv_f + +subroutine ompi_iallgatherv_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,comm,request,ierror) & + BIND(C, name="ompi_iallgatherv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iallgatherv_f + +subroutine ompi_allgatherv_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_allgatherv_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allgatherv_init_f + +subroutine ompi_allreduce_f(sendbuf,recvbuf,count,datatype,op,comm,ierror) & + BIND(C, name="ompi_allreduce_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allreduce_f + +subroutine ompi_iallreduce_f(sendbuf,recvbuf,count,datatype,op,comm,request,ierror) & + BIND(C, name="ompi_iallreduce_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iallreduce_f + +subroutine ompi_allreduce_init_f(sendbuf,recvbuf,count,datatype,op,comm,info,request,ierror) & + BIND(C, name="ompi_allreduce_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_allreduce_init_f + +subroutine ompi_alltoall_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,ierror) & + BIND(C, name="ompi_alltoall_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoall_f + +subroutine ompi_ialltoall_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,request,ierror) & + BIND(C, name="ompi_ialltoall_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ialltoall_f + +subroutine ompi_alltoall_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_alltoall_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoall_init_f + +subroutine ompi_alltoallv_f(sendbuf,sendcounts,sdispls,sendtype, & + recvbuf,recvcounts,rdispls,recvtype,comm,ierror) & + BIND(C, name="ompi_alltoallv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoallv_f + +subroutine ompi_ialltoallv_f(sendbuf,sendcounts,sdispls,sendtype, & + recvbuf,recvcounts,rdispls,recvtype,comm,request,ierror) & + BIND(C, name="ompi_ialltoallv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ialltoallv_f + +subroutine ompi_alltoallv_init_f(sendbuf,sendcounts,sdispls,sendtype, & + recvbuf,recvcounts,rdispls,recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_alltoallv_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoallv_init_f + +subroutine ompi_alltoallw_f(sendbuf,sendcounts,sdispls,sendtypes, & + recvbuf,recvcounts,rdispls,recvtypes,comm,ierror) & + BIND(C, name="ompi_alltoallw_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtypes + INTEGER, INTENT(IN) :: recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoallw_f + +subroutine ompi_ialltoallw_f(sendbuf,sendcounts,sdispls,sendtypes, & + recvbuf,recvcounts,rdispls,recvtypes,comm,request,ierror) & + BIND(C, name="ompi_ialltoallw_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendtypes + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ialltoallw_f + +subroutine ompi_alltoallw_init_f(sendbuf,sendcounts,sdispls,sendtypes, & + recvbuf,recvcounts,rdispls,recvtypes,comm,info,request,ierror) & + BIND(C, name="ompi_alltoallw_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendtypes + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alltoallw_init_f + +subroutine ompi_barrier_f(comm,ierror) & + BIND(C, name="ompi_barrier_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_barrier_f + +subroutine ompi_ibarrier_f(comm,request,ierror) & + BIND(C, name="ompi_ibarrier_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ibarrier_f + +subroutine ompi_barrier_init_f(comm,info,request,ierror) & + BIND(C, name="ompi_barrier_init_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_barrier_init_f + +subroutine ompi_bcast_f(buffer,count,datatype,root,comm,ierror) & + BIND(C, name="ompi_bcast_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buffer + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_bcast_f + +subroutine ompi_ibcast_f(buffer,count,datatype,root,comm,request,ierror) & + BIND(C, name="ompi_ibcast_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buffer + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ibcast_f + +subroutine ompi_bcast_init_f(buffer,count,datatype,root,comm,info,request,ierror) & + BIND(C, name="ompi_bcast_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buffer + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_bcast_init_f + +subroutine ompi_exscan_f(sendbuf,recvbuf,count,datatype,op,comm,ierror) & + BIND(C, name="ompi_exscan_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_exscan_f + +subroutine ompi_iexscan_f(sendbuf,recvbuf,count,datatype,op,comm,request,ierror) & + BIND(C, name="ompi_iexscan_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iexscan_f + +subroutine ompi_exscan_init_f(sendbuf,recvbuf,count,datatype,op,comm,info,request,ierror) & + BIND(C, name="ompi_exscan_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_exscan_init_f + +subroutine ompi_gather_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,ierror) & + BIND(C, name="ompi_gather_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_gather_f + +subroutine ompi_igather_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,request,ierror) & + BIND(C, name="ompi_igather_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_igather_f + +subroutine ompi_gather_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,info,request,ierror) & + BIND(C, name="ompi_gather_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_gather_init_f + +subroutine ompi_gatherv_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,root,comm,ierror) & + BIND(C, name="ompi_gatherv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, root + INTEGER, INTENT(IN) :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_gatherv_f + +subroutine ompi_igatherv_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,root,comm,request,ierror) & + BIND(C, name="ompi_igatherv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, root + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_igatherv_f + +subroutine ompi_gatherv_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcounts,displs,recvtype,root,comm,info,request,ierror) & + BIND(C, name="ompi_gatherv_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, root + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_gatherv_init_f + +subroutine ompi_op_free_f(op,ierror) & + BIND(C, name="ompi_op_free_f") + implicit none + INTEGER, INTENT(INOUT) :: op + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_op_free_f + +subroutine ompi_reduce_f(sendbuf,recvbuf,count,datatype,op,root,comm,ierror) & + BIND(C, name="ompi_reduce_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_f + +subroutine ompi_ireduce_f(sendbuf,recvbuf,count,datatype,op,root,comm,request,ierror) & + BIND(C, name="ompi_ireduce_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ireduce_f + +subroutine ompi_reduce_init_f(sendbuf,recvbuf,count,datatype,op,root,comm,info,request,ierror) & + BIND(C, name="ompi_reduce_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_init_f + +subroutine ompi_reduce_local_f(inbuf,inoutbuf,count,datatype,op,ierror) & + BIND(C, name="ompi_reduce_local_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: inbuf + OMPI_F08_IGNORE_TKR_TYPE :: inoutbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_local_f + +subroutine ompi_reduce_scatter_f(sendbuf,recvbuf,recvcounts, & + datatype,op,comm,ierror) & + BIND(C, name="ompi_reduce_scatter_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: recvcounts(*) + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_scatter_f + +subroutine ompi_ireduce_scatter_f(sendbuf,recvbuf,recvcounts, & + datatype,op,comm,request,ierror) & + BIND(C, name="ompi_ireduce_scatter_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*) + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ireduce_scatter_f + +subroutine ompi_reduce_scatter_init_f(sendbuf,recvbuf,recvcounts, & + datatype,op,comm,info,request,ierror) & + BIND(C, name="ompi_reduce_scatter_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*) + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_scatter_init_f + +subroutine ompi_reduce_scatter_block_f(sendbuf,recvbuf,recvcount, & + datatype,op,comm,ierror) & + BIND(C, name="ompi_reduce_scatter_block_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: recvcount + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_scatter_block_f + +subroutine ompi_ireduce_scatter_block_f(sendbuf,recvbuf,recvcount, & + datatype,op,comm,request,ierror) & + BIND(C, name="ompi_ireduce_scatter_block_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: recvcount + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ireduce_scatter_block_f + +subroutine ompi_reduce_scatter_block_init_f(sendbuf,recvbuf,recvcount, & + datatype,op,comm,info,request,ierror) & + BIND(C, name="ompi_reduce_scatter_block_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: recvcount + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_reduce_scatter_block_init_f + +subroutine ompi_scan_f(sendbuf,recvbuf,count,datatype,op,comm,ierror) & + BIND(C, name="ompi_scan_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scan_f + +subroutine ompi_iscan_f(sendbuf,recvbuf,count,datatype,op,comm,request,ierror) & + BIND(C, name="ompi_iscan_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iscan_f + +subroutine ompi_scan_init_f(sendbuf,recvbuf,count,datatype,op,comm,info,request,ierror) & + BIND(C, name="ompi_scan_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scan_init_f + +subroutine ompi_scatter_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,ierror) & + BIND(C, name="ompi_scatter_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scatter_f + +subroutine ompi_iscatter_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,request,ierror) & + BIND(C, name="ompi_iscatter_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iscatter_f + +subroutine ompi_scatter_init_f(sendbuf,sendcount,sendtype,recvbuf, & + recvcount,recvtype,root,comm,info,request,ierror) & + BIND(C, name="ompi_scatter_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount, root + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scatter_init_f + +subroutine ompi_scatterv_f(sendbuf,sendcounts,displs,sendtype, & + recvbuf,recvcount,recvtype,root,comm,ierror) & + BIND(C, name="ompi_scatterv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: recvcount, root + INTEGER, INTENT(IN) :: sendcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scatterv_f + +subroutine ompi_iscatterv_f(sendbuf,sendcounts,displs,sendtype, & + recvbuf,recvcount,recvtype,root,comm,request,ierror) & + BIND(C, name="ompi_iscatterv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: recvcount, root + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), displs(*) + + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_iscatterv_f + +subroutine ompi_scatterv_init_f(sendbuf,sendcounts,displs,sendtype, & + recvbuf,recvcount,recvtype,root,comm,info,request,ierror) & + BIND(C, name="ompi_scatterv_init_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: recvcount, root + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype + INTEGER, INTENT(IN) :: recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_scatterv_init_f + +subroutine ompi_comm_compare_f(comm1,comm2,result,ierror) & + BIND(C, name="ompi_comm_compare_f") + implicit none + INTEGER, INTENT(IN) :: comm1 + INTEGER, INTENT(IN) :: comm2 + INTEGER, INTENT(OUT) :: result + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_compare_f + +subroutine ompi_comm_create_f(comm,group,newcomm,ierror) & + BIND(C, name="ompi_comm_create_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_create_f + +subroutine ompi_comm_create_from_group_f(group, stringtag, info, errhandler, newcomm, ierror, name_len) & + BIND(C, name="ompi_comm_create_from_group_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + integer, intent(in) :: group + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: stringtag + integer, intent(in) :: info + integer, intent(in) :: errhandler + integer, intent(out) :: newcomm + integer, intent(out) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_comm_create_from_group_f + +subroutine ompi_comm_create_group_f(comm, group, tag, newcomm, ierror) & + BIND(C, name="ompi_comm_create_group_f") + implicit none + integer, intent(in) :: comm + integer, intent(in) :: group + integer, intent(in) :: tag + integer, intent(out) :: newcomm + integer, intent(out) :: ierror +end subroutine ompi_comm_create_group_f + +subroutine ompi_comm_create_keyval_f(comm_copy_attr_fn,comm_delete_attr_fn, & + comm_keyval,extra_state,ierror) & + BIND(C, name="ompi_comm_create_keyval_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: comm_copy_attr_fn + type(c_funptr), value :: comm_delete_attr_fn + INTEGER, INTENT(OUT) :: comm_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: extra_state + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_create_keyval_f + +subroutine ompi_comm_delete_attr_f(comm,comm_keyval,ierror) & + BIND(C, name="ompi_comm_delete_attr_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: comm_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_delete_attr_f + +subroutine ompi_comm_dup_f(comm,newcomm,ierror) & + BIND(C, name="ompi_comm_dup_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_dup_f + +subroutine ompi_comm_dup_with_info_f(comm, info, newcomm, ierror) & + BIND(C, name="ompi_comm_dup_with_info_f") + implicit none + integer, intent(in) :: comm + integer, intent(in) :: info + integer, intent(out) :: newcomm + integer, intent(out) :: ierror +end subroutine ompi_comm_dup_with_info_f + +subroutine ompi_comm_idup_with_info_f(comm, info, newcomm, request, ierror) & + BIND(C, name="ompi_comm_idup_with_info_f") + implicit none + integer, intent(in) :: comm + integer, intent(in) :: info + integer, intent(out) :: newcomm + integer, intent(out) :: request + integer, intent(out) :: ierror +end subroutine ompi_comm_idup_with_info_f + +subroutine ompi_comm_free_f(comm,ierror) & + BIND(C, name="ompi_comm_free_f") + implicit none + INTEGER, INTENT(INOUT) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_free_f + +subroutine ompi_comm_free_keyval_f(comm_keyval,ierror) & + BIND(C, name="ompi_comm_free_keyval_f") + implicit none + INTEGER, INTENT(INOUT) :: comm_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_free_keyval_f + +subroutine ompi_comm_get_info_f(comm,info_used,ierror) & + BIND(C, name="ompi_comm_get_info_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: info_used + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_get_info_f + +subroutine ompi_comm_get_name_f(comm,comm_name,resultlen,ierror,comm_name_len) & + BIND(C, name="ompi_comm_get_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: comm + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: comm_name + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: comm_name_len +end subroutine ompi_comm_get_name_f + +subroutine ompi_comm_from_group_f(group, stringtag, info, errhandler, newcomm, ierror, name_len) & + BIND(C, name="ompi_comm_from_group_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: group + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: stringtag + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_comm_from_group_f + +subroutine ompi_comm_group_f(comm,group,ierror) & + BIND(C, name="ompi_comm_group_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: group + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_group_f + +subroutine ompi_comm_idup_f(comm, newcomm, request, ierror) & + BIND(C, name="ompi_comm_idup_f") + implicit none + integer, intent(in) :: comm + integer, intent(out) OMPI_ASYNCHRONOUS :: newcomm + integer, intent(out) :: request + integer, intent(out) :: ierror +end subroutine ompi_comm_idup_f + +subroutine ompi_comm_rank_f(comm,rank,ierror) & + BIND(C, name="ompi_comm_rank_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: rank + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_rank_f + +subroutine ompi_comm_remote_group_f(comm,group,ierror) & + BIND(C, name="ompi_comm_remote_group_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: group + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_remote_group_f + +subroutine ompi_comm_remote_size_f(comm,size,ierror) & + BIND(C, name="ompi_comm_remote_size_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_remote_size_f + +subroutine ompi_comm_set_attr_f(comm,comm_keyval,attribute_val,ierror) & + BIND(C, name="ompi_comm_set_attr_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: comm_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: attribute_val + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_set_attr_f + +subroutine ompi_comm_set_info_f(comm,info,ierror) & + BIND(C, name="ompi_comm_set_info_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_set_info_f + +subroutine ompi_comm_set_name_f(comm,comm_name,ierror,comm_name_len) & + BIND(C, name="ompi_comm_set_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: comm + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: comm_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: comm_name_len +end subroutine ompi_comm_set_name_f + +subroutine ompi_comm_size_f(comm,size,ierror) & + BIND(C, name="ompi_comm_size_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_size_f + +subroutine ompi_comm_split_f(comm,color,key,newcomm,ierror) & + BIND(C, name="ompi_comm_split_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: color, key + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_split_f + +subroutine ompi_group_compare_f(group1,group2,result,ierror) & + BIND(C, name="ompi_group_compare_f") + implicit none + INTEGER, INTENT(IN) :: group1 + INTEGER, INTENT(IN) :: group2 + INTEGER, INTENT(OUT) :: result + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_compare_f + +subroutine ompi_group_difference_f(group1,group2,newgroup,ierror) & + BIND(C, name="ompi_group_difference_f") + implicit none + INTEGER, INTENT(IN) :: group1 + INTEGER, INTENT(IN) :: group2 + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_difference_f + +subroutine ompi_group_excl_f(group,n,ranks,newgroup,ierror) & + BIND(C, name="ompi_group_excl_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(IN) :: n + INTEGER, INTENT(IN) :: ranks(n) + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_excl_f + +subroutine ompi_group_free_f(group,ierror) & + BIND(C, name="ompi_group_free_f") + implicit none + INTEGER, INTENT(INOUT) :: group + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_free_f + +subroutine ompi_group_from_session_pset_f(session, pset_name, newgroup, ierror, name_len) & + BIND(C, name="ompi_group_from_session_pset_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: session + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: pset_name + INTEGER, INTENT(OUT) :: newgroup + integer, intent(out) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_group_from_session_pset_f + +subroutine ompi_group_incl_f(group,n,ranks,newgroup,ierror) & + BIND(C, name="ompi_group_incl_f") + implicit none + INTEGER, INTENT(IN) :: n + INTEGER, INTENT(IN) :: ranks(n) + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_incl_f + +subroutine ompi_group_intersection_f(group1,group2,newgroup,ierror) & + BIND(C, name="ompi_group_intersection_f") + implicit none + INTEGER, INTENT(IN) :: group1 + INTEGER, INTENT(IN) :: group2 + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_intersection_f + +subroutine ompi_group_range_excl_f(group,n,ranges,newgroup,ierror) & + BIND(C, name="ompi_group_range_excl_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(IN) :: n + INTEGER, INTENT(IN) :: ranges(3, n) + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_range_excl_f + +subroutine ompi_group_range_incl_f(group,n,ranges,newgroup,ierror) & + BIND(C, name="ompi_group_range_incl_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(IN) :: n + INTEGER, INTENT(IN) :: ranges(3, n) + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_range_incl_f + +subroutine ompi_group_rank_f(group,rank,ierror) & + BIND(C, name="ompi_group_rank_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(OUT) :: rank + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_rank_f + +subroutine ompi_group_size_f(group,size,ierror) & + BIND(C, name="ompi_group_size_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_size_f + +subroutine ompi_group_translate_ranks_f(group1,n,ranks1,group2,ranks2,ierror) & + BIND(C, name="ompi_group_translate_ranks_f") + implicit none + INTEGER, INTENT(IN) :: group1, group2 + INTEGER, INTENT(IN) :: n + INTEGER, INTENT(IN) :: ranks1(n) + INTEGER, INTENT(OUT) :: ranks2(n) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_translate_ranks_f + +subroutine ompi_group_union_f(group1,group2,newgroup,ierror) & + BIND(C, name="ompi_group_union_f") + implicit none + INTEGER, INTENT(IN) :: group1, group2 + INTEGER, INTENT(OUT) :: newgroup + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_group_union_f + +subroutine ompi_intercomm_create_f(local_comm,local_leader,peer_comm, & + remote_leader,tag,newintercomm,ierror) & + BIND(C, name="ompi_intercomm_create_f") + implicit none + INTEGER, INTENT(IN) :: local_comm, peer_comm + INTEGER, INTENT(IN) :: local_leader, remote_leader, tag + INTEGER, INTENT(OUT) :: newintercomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_intercomm_create_f + +subroutine ompi_intercomm_create_from_groups_f(local_group, local_leader, remote_group, & + remote_leader, stringtag, info, errhandler, & + newintercomm, ierror, name_len) & + BIND(C, name="ompi_intercomm_create_from_groups_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: local_group, remote_group + INTEGER, INTENT(IN) :: local_leader, remote_leader + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: stringtag + INTEGER, INTENT(IN) :: info, errhandler + INTEGER, INTENT(OUT) :: newintercomm + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_intercomm_create_from_groups_f + +subroutine ompi_type_create_keyval_f(type_copy_attr_fn,type_delete_attr_fn, & + type_keyval,extra_state,ierror) & + BIND(C, name="ompi_type_create_keyval_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: type_copy_attr_fn + type(c_funptr), value :: type_delete_attr_fn + INTEGER, INTENT(OUT) :: type_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: extra_state + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_keyval_f + +subroutine ompi_type_delete_attr_f(datatype,type_keyval,ierror) & + BIND(C, name="ompi_type_delete_attr_f") + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: type_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_delete_attr_f + +subroutine ompi_type_free_keyval_f(type_keyval,ierror) & + BIND(C, name="ompi_type_free_keyval_f") + implicit none + INTEGER, INTENT(INOUT) :: type_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_free_keyval_f + +subroutine ompi_type_get_name_f(datatype,type_name,resultlen,ierror,type_name_len) & + BIND(C, name="ompi_type_get_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: datatype + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: type_name + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: type_name_len +end subroutine ompi_type_get_name_f + +subroutine ompi_type_set_attr_f(datatype,type_keyval,attribute_val,ierror) & + BIND(C, name="ompi_type_set_attr_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: type_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: attribute_val + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_set_attr_f + +subroutine ompi_type_set_name_f(datatype,type_name,ierror,type_name_len) & + BIND(C, name="ompi_type_set_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: datatype + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: type_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: type_name_len +end subroutine ompi_type_set_name_f + +subroutine ompi_win_allocate_f(size, disp_unit, info, comm, & + baseptr, win, ierror) BIND(C, name="ompi_win_allocate_f") + USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_PTR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + INTEGER(KIND=MPI_ADDRESS_KIND), INTENT(IN) :: size + INTEGER, INTENT(IN) :: disp_unit + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: comm + TYPE(C_PTR), INTENT(OUT) :: baseptr + INTEGER, INTENT(OUT) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_allocate_f + +subroutine ompi_win_allocate_shared_f(size, disp_unit, info, comm, & + baseptr, win, ierror) BIND(C, name="ompi_win_allocate_shared_f") + USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_PTR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + INTEGER(KIND=MPI_ADDRESS_KIND), INTENT(IN) :: size + INTEGER, INTENT(IN) :: disp_unit + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: comm + TYPE(C_PTR), INTENT(OUT) :: baseptr + INTEGER, INTENT(OUT) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_allocate_shared_f + +subroutine ompi_win_create_keyval_f(win_copy_attr_fn,win_delete_attr_fn, & + win_keyval,extra_state,ierror) & + BIND(C, name="ompi_win_create_keyval_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: win_copy_attr_fn + type(c_funptr), value :: win_delete_attr_fn + INTEGER, INTENT(OUT) :: win_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: extra_state + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_create_keyval_f + +subroutine ompi_win_delete_attr_f(win,win_keyval,ierror) & + BIND(C, name="ompi_win_delete_attr_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: win_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_delete_attr_f + +subroutine ompi_win_free_keyval_f(win_keyval,ierror) & + BIND(C, name="ompi_win_free_keyval_f") + implicit none + INTEGER, INTENT(INOUT) :: win_keyval + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_free_keyval_f + +subroutine ompi_win_get_name_f(win,win_name,resultlen,ierror,win_name_len) & + BIND(C, name="ompi_win_get_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: win + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: win_name + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: win_name_len +end subroutine ompi_win_get_name_f + +subroutine ompi_win_set_attr_f(win,win_keyval,attribute_val,ierror) & + BIND(C, name="ompi_win_set_attr_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: win_keyval + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: attribute_val + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_set_attr_f + +subroutine ompi_win_set_name_f(win,win_name,ierror,win_name_len) & + BIND(C, name="ompi_win_set_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: win + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: win_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: win_name_len +end subroutine ompi_win_set_name_f + +subroutine ompi_cartdim_get_f(comm,ndims,ierror) & + BIND(C, name="ompi_cartdim_get_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ndims + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_cartdim_get_f + +subroutine ompi_cart_coords_f(comm,rank,maxdims,coords,ierror) & + BIND(C, name="ompi_cart_coords_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: rank, maxdims + INTEGER, INTENT(OUT) :: coords(maxdims) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_cart_coords_f + +subroutine ompi_cart_rank_f(comm,coords,rank,ierror) & + BIND(C, name="ompi_cart_rank_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: coords(*) + INTEGER, INTENT(OUT) :: rank + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_cart_rank_f + +subroutine ompi_cart_shift_f(comm,direction,disp,rank_source,rank_dest,ierror) & + BIND(C, name="ompi_cart_shift_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: direction, disp + INTEGER, INTENT(OUT) :: rank_source, rank_dest + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_cart_shift_f + +subroutine ompi_dims_create_f(nnodes,ndims,dims,ierror) & + BIND(C, name="ompi_dims_create_f") + implicit none + INTEGER, INTENT(IN) :: nnodes, ndims + INTEGER, INTENT(INOUT) :: dims(ndims) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_dims_create_f + +subroutine ompi_dist_graph_neighbors_f(comm,maxindegree,sources,sourceweights, & + maxoutdegree,destinations,destweights,ierror) & + BIND(C, name="ompi_dist_graph_neighbors_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: maxindegree, maxoutdegree + INTEGER, INTENT(OUT) :: sources(maxindegree), destinations(maxoutdegree) + INTEGER, INTENT(OUT) :: sourceweights(maxindegree), destweights(maxoutdegree) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_dist_graph_neighbors_f + +subroutine ompi_graphdims_get_f(comm,nnodes,nedges,ierror) & + BIND(C, name="ompi_graphdims_get_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: nnodes, nedges + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_graphdims_get_f + +subroutine ompi_graph_get_f(comm,maxindex,maxedges,index,edges,ierror) & + BIND(C, name="ompi_graph_get_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: maxindex, maxedges + INTEGER, INTENT(OUT) :: index(maxindex), edges(maxedges) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_graph_get_f + +subroutine ompi_graph_map_f(comm,nnodes,index,edges,newrank,ierror) & + BIND(C, name="ompi_graph_map_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: nnodes + INTEGER, INTENT(IN) :: index(nnodes), edges(*) + INTEGER, INTENT(OUT) :: newrank + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_graph_map_f + +subroutine ompi_graph_neighbors_f(comm,rank,maxneighbors,neighbors,ierror) & + BIND(C, name="ompi_graph_neighbors_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: rank, maxneighbors + INTEGER, INTENT(OUT) :: neighbors(maxneighbors) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_graph_neighbors_f + +subroutine ompi_graph_neighbors_count_f(comm,rank,nneighbors,ierror) & + BIND(C, name="ompi_graph_neighbors_count_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: rank + INTEGER, INTENT(OUT) :: nneighbors + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_graph_neighbors_count_f + +subroutine ompi_topo_test_f(comm,status,ierror) & + BIND(C, name="ompi_topo_test_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_topo_test_f + +function ompi_wtick_f() & + BIND(C, name="ompi_wtick_f") + implicit none + DOUBLE PRECISION :: ompi_wtick_f +end function ompi_wtick_f + +function ompi_wtime_f() & + BIND(C, name="ompi_wtime_f") + implicit none + DOUBLE PRECISION :: ompi_wtime_f +end function ompi_wtime_f + +function ompi_aint_add_f(base,diff) & + BIND(C, name="ompi_aint_add_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: base + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: diff + INTEGER(MPI_ADDRESS_KIND) :: ompi_aint_add_f +end function ompi_aint_add_f + +function ompi_aint_diff_f(addr1,addr2) & + BIND(C, name="ompi_aint_diff_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: addr1 + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: addr2 + INTEGER(MPI_ADDRESS_KIND) :: ompi_aint_diff_f +end function ompi_aint_diff_f + +subroutine ompi_abort_f(comm,errorcode,ierror) & + BIND(C, name="ompi_abort_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_abort_f + +subroutine ompi_add_error_class_f(errorclass,ierror) & + BIND(C, name="ompi_add_error_class_f") + implicit none + INTEGER, INTENT(OUT) :: errorclass + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_add_error_class_f + +subroutine ompi_add_error_code_f(errorclass,errorcode,ierror) & + BIND(C, name="ompi_add_error_code_f") + implicit none + INTEGER, INTENT(IN) :: errorclass + INTEGER, INTENT(OUT) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_add_error_code_f + +subroutine ompi_add_error_string_f(errorcode,string,ierror,str_len) & + BIND(C, name="ompi_add_error_string_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: errorcode + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: string + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: str_len +end subroutine ompi_add_error_string_f + +subroutine ompi_alloc_mem_f(size,info,baseptr,ierror) & + BIND(C, name="ompi_alloc_mem_f") + use, intrinsic :: ISO_C_BINDING, only : C_PTR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size + INTEGER, INTENT(IN) :: info + TYPE(C_PTR), INTENT(OUT) :: baseptr + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_alloc_mem_f + +subroutine ompi_comm_call_errhandler_f(comm,errorcode,ierror) & + BIND(C, name="ompi_comm_call_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_call_errhandler_f + +subroutine ompi_comm_create_errhandler_f(comm_errhandler_fn,errhandler,ierror) & + BIND(C, name="ompi_comm_create_errhandler_f") + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: comm_errhandler_fn + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_create_errhandler_f + +subroutine ompi_comm_get_errhandler_f(comm,errhandler,ierror) & + BIND(C, name="ompi_comm_get_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_get_errhandler_f + +subroutine ompi_comm_set_errhandler_f(comm,errhandler,ierror) & + BIND(C, name="ompi_comm_set_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_set_errhandler_f + +subroutine ompi_errhandler_free_f(errhandler,ierror) & + BIND(C, name="ompi_errhandler_free_f") + implicit none + INTEGER, INTENT(INOUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_errhandler_free_f + +subroutine ompi_error_class_f(errorcode,errorclass,ierror) & + BIND(C, name="ompi_error_class_f") + implicit none + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: errorclass + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_error_class_f + +subroutine ompi_error_string_f(errorcode,string,resultlen,ierror,str_len) & + BIND(C, name="ompi_error_string_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: errorcode + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: string + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: str_len +end subroutine ompi_error_string_f + +subroutine ompi_file_call_errhandler_f(fh,errorcode,ierror) & + BIND(C, name="ompi_file_call_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_call_errhandler_f + +subroutine ompi_file_create_errhandler_f(file_errhandler_fn,errhandler,ierror) & + BIND(C, name="ompi_file_create_errhandler_f") + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: file_errhandler_fn + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_create_errhandler_f + +subroutine ompi_file_get_errhandler_f(file,errhandler,ierror) & + BIND(C, name="ompi_file_get_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: file + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_errhandler_f + +subroutine ompi_file_set_errhandler_f(file,errhandler,ierror) & + BIND(C, name="ompi_file_set_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: file + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_set_errhandler_f + +subroutine ompi_finalize_f(ierror) & + BIND(C, name="ompi_finalize_f") + implicit none + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_finalize_f + +subroutine ompi_free_mem_f(base,ierror) & + BIND(C, name="ompi_free_mem_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: base + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_free_mem_f + +subroutine ompi_get_processor_name_f(name,resultlen,ierror,name_len) & + BIND(C, name="ompi_get_processor_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: name + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_get_processor_name_f + +subroutine ompi_get_version_f(version,subversion,ierror) & + BIND(C, name="ompi_get_version_f") + implicit none + INTEGER, INTENT(OUT) :: version, subversion + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_version_f + +subroutine ompi_init_f(ierror) & + BIND(C, name="ompi_init_f") + implicit none + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_init_f + +subroutine ompi_win_call_errhandler_f(win,errorcode,ierror) & + BIND(C, name="ompi_win_call_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_call_errhandler_f + +subroutine ompi_win_create_errhandler_f(win_errhandler_fn,errhandler,ierror) & + BIND(C, name="ompi_win_create_errhandler_f") + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: win_errhandler_fn + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_create_errhandler_f + +subroutine ompi_win_get_errhandler_f(win,errhandler,ierror) & + BIND(C, name="ompi_win_get_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_get_errhandler_f + +subroutine ompi_win_set_errhandler_f(win,errhandler,ierror) & + BIND(C, name="ompi_win_set_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_set_errhandler_f + +subroutine ompi_info_create_f(info,ierror) & + BIND(C, name="ompi_info_create_f") + implicit none + INTEGER, INTENT(OUT) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_info_create_f + +subroutine ompi_info_create_env_f(info,ierror) & + BIND(C, name="ompi_info_create_env_f") + implicit none + INTEGER, INTENT(OUT) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_info_create_env_f + +subroutine ompi_info_delete_f(info,key,ierror,key_len) & + BIND(C, name="ompi_info_delete_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: info + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: key + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: key_len +end subroutine ompi_info_delete_f + +subroutine ompi_info_dup_f(info,newinfo,ierror) & + BIND(C, name="ompi_info_dup_f") + implicit none + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: newinfo + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_info_dup_f + +subroutine ompi_info_free_f(info,ierror) & + BIND(C, name="ompi_info_free_f") + implicit none + INTEGER, INTENT(INOUT) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_info_free_f + +subroutine ompi_info_get_nkeys_f(info,nkeys,ierror) & + BIND(C, name="ompi_info_get_nkeys_f") + implicit none + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: nkeys + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_info_get_nkeys_f + +subroutine ompi_info_get_nthkey_f(info,n,key,ierror,key_len) & + BIND(C, name="ompi_info_get_nthkey_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: n + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: key + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: key_len +end subroutine ompi_info_get_nthkey_f + +subroutine ompi_info_set_f(info,key,value,ierror,key_len,value_len) & + BIND(C, name="ompi_info_set_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: info + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: key, value + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: key_len, value_len +end subroutine ompi_info_set_f + +subroutine ompi_close_port_f(port_name,ierror,port_name_len) & + BIND(C, name="ompi_close_port_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: port_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: port_name_len +end subroutine ompi_close_port_f + +subroutine ompi_comm_accept_f(port_name,info,root,comm,newcomm,ierror,port_name_len) & + BIND(C, name="ompi_comm_accept_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: port_name + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: root + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: port_name_len +end subroutine ompi_comm_accept_f + +subroutine ompi_comm_connect_f(port_name,info,root,comm,newcomm,ierror,port_name_len) & + BIND(C, name="ompi_comm_connect_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: port_name + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: root + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: port_name_len +end subroutine ompi_comm_connect_f + +subroutine ompi_comm_disconnect_f(comm,ierror) & + BIND(C, name="ompi_comm_disconnect_f") + implicit none + INTEGER, INTENT(INOUT) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_disconnect_f + +subroutine ompi_comm_get_parent_f(parent,ierror) & + BIND(C, name="ompi_comm_get_parent_f") + implicit none + INTEGER, INTENT(OUT) :: parent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_get_parent_f + +subroutine ompi_comm_join_f(fd,intercomm,ierror) & + BIND(C, name="ompi_comm_join_f") + implicit none + INTEGER, INTENT(IN) :: fd + INTEGER, INTENT(OUT) :: intercomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_join_f + +subroutine ompi_comm_spawn_f(command,argv,maxprocs,info,root,comm, & + intercomm, array_of_errcodes,ierror,cmd_len,argv_len) & + BIND(C, name="ompi_comm_spawn_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: command, argv + INTEGER, INTENT(IN) :: maxprocs, root + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: intercomm + INTEGER, INTENT(OUT) :: array_of_errcodes(*) + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: cmd_len, argv_len +end subroutine ompi_comm_spawn_f + + +! TODO - FIXME to use arrays of strings and pass strlen +subroutine ompi_comm_spawn_multiple_f(count,array_of_commands, & + array_of_argv, array_of_maxprocs,array_of_info,root, & + comm,intercomm,array_of_errcodes,ierror, & + cmd_len, argv_len) & + BIND(C, name="ompi_comm_spawn_multiple_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: count, root + INTEGER, INTENT(IN) :: array_of_maxprocs(count) + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: array_of_commands(*), array_of_argv(*) + INTEGER, INTENT(IN) :: array_of_info(count) + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: intercomm + INTEGER, INTENT(OUT) :: array_of_errcodes(*) + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: cmd_len, argv_len +end subroutine ompi_comm_spawn_multiple_f + +subroutine ompi_lookup_name_f(service_name,info,port_name,ierror, & + service_name_len,port_name_len) & + BIND(C, name="ompi_lookup_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: service_name + INTEGER, INTENT(IN) :: info + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: port_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: service_name_len, port_name_len +end subroutine ompi_lookup_name_f + +subroutine ompi_open_port_f(info,port_name,ierror,port_name_len) & + BIND(C, name="ompi_open_port_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: info + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: port_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: port_name_len +end subroutine ompi_open_port_f + +subroutine ompi_publish_name_f(service_name,info,port_name,ierror, & + service_name_len,port_name_len) & + BIND(C, name="ompi_publish_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: info + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: service_name, port_name + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: service_name_len, port_name_len +end subroutine ompi_publish_name_f + +subroutine ompi_unpublish_name_f(service_name,info,port_name, & + ierror,service_name_len,port_name_len) & + BIND(C, name="ompi_unpublish_name_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: service_name, port_name + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: service_name_len, port_name_len +end subroutine ompi_unpublish_name_f + +subroutine ompi_accumulate_f(origin_addr,origin_count,origin_datatype, & + target_rank,target_disp, & + target_count,target_datatype,op,win,ierror) & + BIND(C, name="ompi_accumulate_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_accumulate_f + +subroutine ompi_raccumulate_f(origin_addr,origin_count,origin_datatype, & + target_rank,target_disp, & + target_count,target_datatype,op,win, & + request,ierror) & + BIND(C, name="ompi_raccumulate_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_raccumulate_f + +subroutine ompi_get_f(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,ierror) & + BIND(C, name="ompi_get_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_f + +subroutine ompi_rget_f(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,request, & + ierror) & + BIND(C, name="ompi_rget_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_rget_f + +subroutine ompi_get_accumulate_f(origin_addr,origin_count,origin_datatype, & + result_addr,result_count,result_datatype, & + target_rank,target_disp, & + target_count,target_datatype,op,win, & + ierror) & + BIND(C, name="ompi_get_accumulate_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, result_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + INTEGER, INTENT(IN) :: result_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_get_accumulate_f + +subroutine ompi_rget_accumulate_f(origin_addr,origin_count,origin_datatype, & + result_addr,result_count,result_datatype, & + target_rank,target_disp, & + target_count,target_datatype,op,win, & + request,ierror) & + BIND(C, name="ompi_rget_accumulate_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, result_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + INTEGER, INTENT(IN) :: result_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_rget_accumulate_f + +subroutine ompi_put_f(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,ierror) & + BIND(C, name="ompi_put_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_put_f + +subroutine ompi_rput_f(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,request, & + ierror) & + BIND(C, name="ompi_rput_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + INTEGER, INTENT(IN) :: origin_count, target_rank, target_count + INTEGER, INTENT(IN) :: origin_datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: target_datatype + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_rput_f + +subroutine ompi_win_complete_f(win,ierror) & + BIND(C, name="ompi_win_complete_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_complete_f + +subroutine ompi_compare_and_swap_f(origin_addr,compare_addr,result_addr, & + datatype,target_rank,target_disp, win, & + ierror) & + BIND(C, name="ompi_compare_and_swap_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr, compare_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: target_rank + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_compare_and_swap_f + +subroutine ompi_fetch_and_op_f(origin_addr,result_addr,datatype,target_rank, & + target_disp,op,win,ierror) & + BIND(C, name="ompi_fetch_and_op_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: target_rank + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp + INTEGER, INTENT(IN) :: op + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_fetch_and_op_f + +subroutine ompi_win_create_f(base,size,disp_unit,info,comm,win,ierror) & + BIND(C, name="ompi_win_create_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size + INTEGER, INTENT(IN) :: disp_unit + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_create_f + +subroutine ompi_win_create_dynamic_f(info,comm,win,ierror) & + BIND(C, name="ompi_win_create_dynamic_f") + implicit none + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_create_dynamic_f + +subroutine ompi_win_attach_f(win,base,size,ierror) & + BIND(C, name="ompi_win_attach_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_attach_f + +subroutine ompi_win_detach_f(win,base,ierror) & + BIND(C, name="ompi_win_detach_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_detach_f + +subroutine ompi_win_flush_f(rank,win,ierror) & + BIND(C, name="ompi_win_flush_f") + implicit none + INTEGER, INTENT(IN) :: rank + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_flush_f + +subroutine ompi_win_flush_all_f(win,ierror) & + BIND(C, name="ompi_win_flush_all_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_flush_all_f + +subroutine ompi_win_flush_local_f(rank,win,ierror) & + BIND(C, name="ompi_win_flush_local_f") + implicit none + INTEGER, INTENT(IN) :: rank + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_flush_local_f + +subroutine ompi_win_flush_local_all_f(win,ierror) & + BIND(C, name="ompi_win_flush_local_all_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_flush_local_all_f + +subroutine ompi_win_fence_f(assert,win,ierror) & + BIND(C, name="ompi_win_fence_f") + implicit none + INTEGER, INTENT(IN) :: assert + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_fence_f + +subroutine ompi_win_free_f(win,ierror) & + BIND(C, name="ompi_win_free_f") + implicit none + INTEGER, INTENT(INOUT) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_free_f + +subroutine ompi_win_get_group_f(win,group,ierror) & + BIND(C, name="ompi_win_get_group_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: group + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_get_group_f + +subroutine ompi_win_get_info_f(win,info_used,ierror) & + BIND(C, name="ompi_win_get_info_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: info_used + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_get_info_f + +subroutine ompi_win_lock_f(lock_type,rank,assert,win,ierror) & + BIND(C, name="ompi_win_lock_f") + implicit none + INTEGER, INTENT(IN) :: lock_type, rank, assert + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_lock_f + +subroutine ompi_win_lock_all_f(assert,win,ierror) & + BIND(C, name="ompi_win_lock_all_f") + implicit none + INTEGER, INTENT(IN) :: assert + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_lock_all_f + +subroutine ompi_win_post_f(group,assert,win,ierror) & + BIND(C, name="ompi_win_post_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(IN) :: assert + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_post_f + +subroutine ompi_win_set_info_f(win,info,ierror) & + BIND(C, name="ompi_win_set_info_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_set_info_f + +subroutine ompi_win_shared_query_f(win, rank, size, disp_unit, baseptr,& + ierror) BIND(C, name="ompi_win_shared_query_f") + USE, INTRINSIC :: ISO_C_BINDING, ONLY : C_PTR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(IN) :: rank + INTEGER(KIND=MPI_ADDRESS_KIND), INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: disp_unit + TYPE(C_PTR), INTENT(OUT) :: baseptr + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_shared_query_f + +subroutine ompi_win_start_f(group,assert,win,ierror) & + BIND(C, name="ompi_win_start_f") + implicit none + INTEGER, INTENT(IN) :: group + INTEGER, INTENT(IN) :: assert + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_start_f + +subroutine ompi_win_sync_f(win,ierror) & + BIND(C, name="ompi_win_sync_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_sync_f + +subroutine ompi_win_unlock_f(rank,win,ierror) & + BIND(C, name="ompi_win_unlock_f") + implicit none + INTEGER, INTENT(IN) :: rank + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_unlock_f + +subroutine ompi_win_unlock_all_f(win,ierror) & + BIND(C, name="ompi_win_unlock_all_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_unlock_all_f + +subroutine ompi_win_wait_f(win,ierror) & + BIND(C, name="ompi_win_wait_f") + implicit none + INTEGER, INTENT(IN) :: win + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_win_wait_f + +subroutine ompi_grequest_complete_f(request,ierror) & + BIND(C, name="ompi_grequest_complete_f") + implicit none + INTEGER, INTENT(IN) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_grequest_complete_f + +subroutine ompi_grequest_start_f(query_fn,free_fn,cancel_fn, & + extra_state,request,ierror) & + BIND(C, name="ompi_grequest_start_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: query_fn + type(c_funptr), value :: free_fn + type(c_funptr), value :: cancel_fn + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: extra_state + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_grequest_start_f + +subroutine ompi_init_thread_f(required,provided,ierror) & + BIND(C, name="ompi_init_thread_f") + implicit none + INTEGER, INTENT(IN) :: required + INTEGER, INTENT(OUT) :: provided + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_init_thread_f + +subroutine ompi_query_thread_f(provided,ierror) & + BIND(C, name="ompi_query_thread_f") + implicit none + INTEGER, INTENT(OUT) :: provided + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_query_thread_f + +subroutine ompi_status_f082f_f(f08_status,f_status,ierror) & + BIND(C, name="ompi_status_f082f_f") + use :: mpi_f08_types, only : MPI_Status, MPI_STATUS_SIZE + implicit none + TYPE(MPI_Status), INTENT(IN) :: f08_status + INTEGER, INTENT(OUT) :: f_status(MPI_STATUS_SIZE) + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_status_f082f_f + +subroutine ompi_status_f2f08_f(f_status,f08_status,ierror) & + BIND(C, name="ompi_status_f2f08_f") + use :: mpi_f08_types, only : MPI_Status, MPI_STATUS_SIZE + implicit none + INTEGER, INTENT(IN) :: f_status(MPI_STATUS_SIZE) + TYPE(MPI_Status), INTENT(OUT) :: f08_status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_status_f2f08_f + +subroutine ompi_status_set_elements_f(status,datatype,count,ierror) & + BIND(C, name="ompi_status_set_elements_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + TYPE(MPI_Status), INTENT(INOUT) :: status + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_status_set_elements_f + +subroutine ompi_status_set_elements_x_f(status,datatype,count,ierror) & + BIND(C, name="ompi_status_set_elements_x_f") + use :: mpi_f08_types, only : MPI_Status, MPI_COUNT_KIND + implicit none + TYPE(MPI_Status), INTENT(INOUT) :: status + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_COUNT_KIND), INTENT(IN) :: count + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_status_set_elements_x_f + +subroutine ompi_file_close_f(fh,ierror) & + BIND(C, name="ompi_file_close_f") + implicit none + INTEGER, INTENT(INOUT) :: fh + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_close_f + +subroutine ompi_file_delete_f(filename,info,ierror,filename_len) & + BIND(C, name="ompi_file_delete_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: filename + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: filename_len +end subroutine ompi_file_delete_f + +subroutine ompi_file_get_amode_f(fh,amode,ierror) & + BIND(C, name="ompi_file_get_amode_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(OUT) :: amode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_amode_f + +subroutine ompi_file_get_byte_offset_f(fh,offset,disp,ierror) & + BIND(C, name="ompi_file_get_byte_offset_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + INTEGER(MPI_OFFSET_KIND), INTENT(OUT) :: disp + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_byte_offset_f + +subroutine ompi_file_get_group_f(fh,group,ierror) & + BIND(C, name="ompi_file_get_group_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(OUT) :: group + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_group_f + +subroutine ompi_file_get_info_f(fh,info_used,ierror) & + BIND(C, name="ompi_file_get_info_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(OUT) :: info_used + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_info_f + +subroutine ompi_file_get_position_f(fh,offset,ierror) & + BIND(C, name="ompi_file_get_position_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(OUT) :: offset + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_position_f + +subroutine ompi_file_get_position_shared_f(fh,offset,ierror) & + BIND(C, name="ompi_file_get_position_shared_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(OUT) :: offset + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_position_shared_f + +subroutine ompi_file_get_size_f(fh,size,ierror) & + BIND(C, name="ompi_file_get_size_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(OUT) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_size_f + +subroutine ompi_file_get_type_extent_f(fh,datatype,extent,ierror) & + BIND(C, name="ompi_file_get_type_extent_f") + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(IN) :: datatype + INTEGER(MPI_ADDRESS_KIND), INTENT(OUT) :: extent + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_get_type_extent_f + +subroutine ompi_file_get_view_f(fh,disp,etype,filetype,datarep,ierror,datarep_len) & + BIND(C, name="ompi_file_get_view_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(OUT) :: disp + INTEGER, INTENT(OUT) :: etype + INTEGER, INTENT(OUT) :: filetype + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: datarep + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_file_get_view_f + +subroutine ompi_file_iread_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iread_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iread_f + +subroutine ompi_file_iread_at_f(fh,offset,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iread_at_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iread_at_f + +subroutine ompi_file_iread_all_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iread_all_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iread_all_f + +subroutine ompi_file_iread_at_all_f(fh,offset,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iread_at_all_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iread_at_all_f + +subroutine ompi_file_iread_shared_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iread_shared_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iread_shared_f + +subroutine ompi_file_iwrite_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iwrite_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iwrite_f + +subroutine ompi_file_iwrite_at_f(fh,offset,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iwrite_at_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iwrite_at_f + +subroutine ompi_file_iwrite_all_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iwrite_all_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iwrite_all_f + +subroutine ompi_file_iwrite_at_all_f(fh,offset,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iwrite_at_all_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iwrite_at_all_f + +subroutine ompi_file_iwrite_shared_f(fh,buf,count,datatype,request,ierror) & + BIND(C, name="ompi_file_iwrite_shared_f") + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_iwrite_shared_f + +subroutine ompi_file_open_f(comm,filename,amode,info,fh,ierror,filename_len) & + BIND(C, name="ompi_file_open_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: comm + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: filename + INTEGER, INTENT(IN) :: amode + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: fh + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: filename_len +end subroutine ompi_file_open_f + +subroutine ompi_file_preallocate_f(fh,size,ierror) & + BIND(C, name="ompi_file_preallocate_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_preallocate_f + +subroutine ompi_file_read_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_f + +subroutine ompi_file_read_all_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_all_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_all_f + +subroutine ompi_file_read_all_begin_f(fh,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_read_all_begin_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_all_begin_f + +subroutine ompi_file_read_all_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_read_all_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_all_end_f + +subroutine ompi_file_read_at_f(fh,offset,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_at_f") + use :: mpi_f08_types, only : MPI_Status, MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_at_f + +subroutine ompi_file_read_at_all_f(fh,offset,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_at_all_f") + use :: mpi_f08_types, only : MPI_Status, MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_at_all_f + +subroutine ompi_file_read_at_all_begin_f(fh,offset,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_read_at_all_begin_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_at_all_begin_f + +subroutine ompi_file_read_at_all_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_read_at_all_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_at_all_end_f + +subroutine ompi_file_read_ordered_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_ordered_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_ordered_f + +subroutine ompi_file_read_ordered_begin_f(fh,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_read_ordered_begin_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_ordered_begin_f + +subroutine ompi_file_read_ordered_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_read_ordered_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_ordered_end_f + +subroutine ompi_file_read_shared_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_read_shared_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_read_shared_f + +subroutine ompi_file_seek_f(fh,offset,whence,ierror) & + BIND(C, name="ompi_file_seek_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + INTEGER, INTENT(IN) :: whence + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_seek_f + +subroutine ompi_file_seek_shared_f(fh,offset,whence,ierror) & + BIND(C, name="ompi_file_seek_shared_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + INTEGER, INTENT(IN) :: whence + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_seek_shared_f + +subroutine ompi_file_set_info_f(fh,info,ierror) & + BIND(C, name="ompi_file_set_info_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_set_info_f + +subroutine ompi_file_set_size_f(fh,size,ierror) & + BIND(C, name="ompi_file_set_size_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: size + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_set_size_f + +subroutine ompi_file_set_view_f(fh,disp,etype,filetype,datarep,info,ierror,datarep_len) & + BIND(C, name="ompi_file_set_view_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: disp + INTEGER, INTENT(IN) :: etype + INTEGER, INTENT(IN) :: filetype + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: datarep + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_file_set_view_f + +subroutine ompi_file_sync_f(fh,ierror) & + BIND(C, name="ompi_file_sync_f") + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_sync_f + +subroutine ompi_file_write_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_f + +subroutine ompi_file_write_all_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_all_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_all_f + +subroutine ompi_file_write_all_begin_f(fh,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_write_all_begin_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_all_begin_f + +subroutine ompi_file_write_all_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_write_all_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_all_end_f + +subroutine ompi_file_write_at_f(fh,offset,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_at_f") + use :: mpi_f08_types, only : MPI_Status, MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_at_f + +subroutine ompi_file_write_at_all_f(fh,offset,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_at_all_f") + use :: mpi_f08_types, only : MPI_Status, MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_at_all_f + +subroutine ompi_file_write_at_all_begin_f(fh,offset,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_write_at_all_begin_f") + use :: mpi_f08_types, only : MPI_OFFSET_KIND + implicit none + INTEGER, INTENT(IN) :: fh + INTEGER(MPI_OFFSET_KIND), INTENT(IN) :: offset + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_at_all_begin_f + +subroutine ompi_file_write_at_all_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_write_at_all_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_at_all_end_f + +subroutine ompi_file_write_ordered_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_ordered_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_ordered_f + +subroutine ompi_file_write_ordered_begin_f(fh,buf,count,datatype,ierror) & + BIND(C, name="ompi_file_write_ordered_begin_f") + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_ordered_begin_f + +subroutine ompi_file_write_ordered_end_f(fh,buf,status,ierror) & + BIND(C, name="ompi_file_write_ordered_end_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: buf + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_ordered_end_f + +subroutine ompi_file_write_shared_f(fh,buf,count,datatype,status,ierror) & + BIND(C, name="ompi_file_write_shared_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: fh + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_file_write_shared_f + +subroutine ompi_register_datarep_f(datarep,read_conversion_fn, & + write_conversion_fn,dtype_file_extent_fn, & + extra_state,ierror,datarep_len) & + BIND(C, name="ompi_register_datarep_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + use :: mpi_f08_types, only : MPI_ADDRESS_KIND + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: read_conversion_fn + type(c_funptr), value :: write_conversion_fn + type(c_funptr), value :: dtype_file_extent_fn + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: datarep + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: extra_state + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: datarep_len +end subroutine ompi_register_datarep_f + +! +! MPI_Sizeof is generic for numeric types. This ignore TKR interface +! is replaced by the specific generics. +! +!subroutine ompi_sizeof(x,size,ierror) & +! BIND(C, name="ompi_sizeof_f") +! implicit none +! OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: x +! INTEGER, INTENT(OUT) :: size +! INTEGER, INTENT(OUT) :: ierror +!end subroutine ompi_sizeof + +subroutine ompi_type_create_f90_complex_f(p,r,newtype,ierror) & + BIND(C, name="ompi_type_create_f90_complex_f") + implicit none + INTEGER, INTENT(IN) :: p, r + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_f90_complex_f + +subroutine ompi_type_create_f90_integer_f(r,newtype,ierror) & + BIND(C, name="ompi_type_create_f90_integer_f") + implicit none + INTEGER, INTENT(IN) :: r + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_f90_integer_f + +subroutine ompi_type_create_f90_real_f(p,r,newtype,ierror) & + BIND(C, name="ompi_type_create_f90_real_f") + implicit none + INTEGER, INTENT(IN) :: p, r + INTEGER, INTENT(OUT) :: newtype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_create_f90_real_f + +subroutine ompi_type_match_size_f(typeclass,size,datatype,ierror) & + BIND(C, name="ompi_type_match_size_f") + implicit none + INTEGER, INTENT(IN) :: typeclass, size + INTEGER, INTENT(OUT) :: datatype + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_type_match_size_f + +subroutine ompi_pcontrol_f(level) & + BIND(C, name="ompi_pcontrol_f") + implicit none + INTEGER, INTENT(IN) :: level +end subroutine ompi_pcontrol_f + + +!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! +! New routines to MPI-3 +! + +subroutine ompi_comm_split_type_f(comm,split_type,key,info,newcomm,ierror) & + BIND(C, name="ompi_comm_split_type_f") + implicit none + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: split_type + INTEGER, INTENT(IN) :: key + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: newcomm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_comm_split_type_f + +subroutine ompi_f_sync_reg_f(buf) & + BIND(C, name="ompi_f_sync_reg_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buf +end subroutine ompi_f_sync_reg_f + +subroutine ompi_get_library_version_f(name,resultlen,ierror,name_len) & + BIND(C, name="ompi_get_library_version_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: name + INTEGER, INTENT(OUT) :: resultlen + INTEGER, INTENT(OUT) :: ierror + INTEGER, VALUE, INTENT(IN) :: name_len +end subroutine ompi_get_library_version_f + +subroutine ompi_mprobe_f(source,tag,comm,message,status,ierror) & + BIND(C, name="ompi_mprobe_f") + use :: mpi_f08_types, only : MPI_Status + implicit none + INTEGER, INTENT(IN) :: source, tag + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: message + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_mprobe_f + +subroutine ompi_imrecv_f(buf,count,datatype,message,request,ierror) & + BIND(C, name="ompi_imrecv_@OMPI_F08_BINDINGS_EXTENSION@") + implicit none + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(INOUT) :: message + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_imrecv_f + +subroutine ompi_mrecv_f(buf,count,datatype,message,status,ierror) & + BIND(C, name="ompi_mrecv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Status + implicit none + OMPI_F08_IGNORE_TKR_TYPE :: buf + INTEGER, INTENT(IN) :: count + INTEGER, INTENT(IN) :: datatype + INTEGER, INTENT(INOUT) :: message + TYPE(MPI_Status) :: status + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_mrecv_f + +subroutine ompi_neighbor_allgather_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,ierror) & + BIND(C, name="ompi_neighbor_allgather_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_allgather_f + +subroutine ompi_ineighbor_allgather_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,request,ierror) & + BIND(C, name="ompi_ineighbor_allgather_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ineighbor_allgather_f + +subroutine ompi_neighbor_allgather_init_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,info,request,ierror) & + BIND(C, name="ompi_neighbor_allgather_init_f") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_allgather_init_f + +subroutine ompi_neighbor_allgatherv_f(sendbuf,sendcount,sendtype,recvbuf,recvcounts,displs, & + recvtype,comm,ierror) & + BIND(C, name="ompi_neighbor_allgatherv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_allgatherv_f + +subroutine ompi_ineighbor_allgatherv_f(sendbuf,sendcount,sendtype,recvbuf,recvcounts,displs, & + recvtype,comm,request,ierror) & + BIND(C, name="ompi_ineighbor_allgatherv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ineighbor_allgatherv_f + +subroutine ompi_neighbor_allgatherv_init_f(sendbuf,sendcount,sendtype,recvbuf,recvcounts,displs, & + recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_neighbor_allgatherv_init_f") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount + INTEGER, INTENT(IN) :: recvcounts(*), displs(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_allgatherv_init_f + +subroutine ompi_neighbor_alltoall_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,ierror) & + BIND(C, name="ompi_neighbor_alltoall_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoall_f + +subroutine ompi_ineighbor_alltoall_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,request,ierror) & + BIND(C, name="ompi_ineighbor_alltoall_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ineighbor_alltoall_f + +subroutine ompi_neighbor_alltoall_init_f(sendbuf,sendcount,sendtype,recvbuf,recvcount,recvtype, & + comm,info,request,ierror) & + BIND(C, name="ompi_neighbor_alltoall_init_f") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcount, recvcount + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoall_init_f + +subroutine ompi_neighbor_alltoallv_f(sendbuf,sendcounts,sdispls,sendtype,recvbuf,recvcounts, & + rdispls,recvtype,comm,ierror) & + BIND(C, name="ompi_neighbor_alltoallv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoallv_f + +subroutine ompi_ineighbor_alltoallv_f(sendbuf,sendcounts,sdispls,sendtype,recvbuf,recvcounts, & + rdispls,recvtype,comm,request,ierror) & + BIND(C, name="ompi_ineighbor_alltoallv_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ineighbor_alltoallv_f + +subroutine ompi_neighbor_alltoallv_init_f(sendbuf,sendcounts,sdispls,sendtype,recvbuf,recvcounts, & + rdispls,recvtype,comm,info,request,ierror) & + BIND(C, name="ompi_neighbor_alltoallv_init_f") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), sdispls(*), recvcounts(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtype, recvtype + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoallv_init_f + +subroutine ompi_neighbor_alltoallw_f(sendbuf,sendcounts,sdispls,sendtypes,recvbuf,recvcounts, & + rdispls,recvtypes,comm,ierror) & + BIND(C, name="ompi_neighbor_alltoallw_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), recvcounts(*) + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: sdispls(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtypes, recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoallw_f + +subroutine ompi_ineighbor_alltoallw_f(sendbuf,sendcounts,sdispls,sendtypes,recvbuf,recvcounts, & + rdispls,recvtypes,comm,request,ierror) & + BIND(C, name="ompi_ineighbor_alltoallw_@OMPI_F08_BINDINGS_EXTENSION@") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request, MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: recvbuf + INTEGER, INTENT(IN) OMPI_ASYNCHRONOUS :: sendcounts(*), recvcounts(*) + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) OMPI_ASYNCHRONOUS :: sdispls(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtypes, recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_ineighbor_alltoallw_f + +subroutine ompi_neighbor_alltoallw_init_f(sendbuf,sendcounts,sdispls,sendtypes,recvbuf,recvcounts, & + rdispls,recvtypes,comm,info,request,ierror) & + BIND(C, name="ompi_neighbor_alltoallw_init_f") + use :: mpi_f08_types, only : MPI_Datatype, MPI_Comm, MPI_Request, MPI_ADDRESS_KIND + implicit none + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) :: sendbuf + OMPI_F08_IGNORE_TKR_TYPE :: recvbuf + INTEGER, INTENT(IN) :: sendcounts(*), recvcounts(*) + INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: sdispls(*), rdispls(*) + INTEGER, INTENT(IN) :: sendtypes, recvtypes + INTEGER, INTENT(IN) :: comm + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(OUT) :: request + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_neighbor_alltoallw_init_f + +subroutine ompi_session_get_info_f(session, info, ierror) & + BIND(C, name="ompi_session_get_info_f") + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(out) :: info + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_get_info_f + +subroutine ompi_session_get_nth_pset_f(session, info, n, pset_len, pset_name, ierror, pset_name_len) & + BIND(C, name="ompi_session_get_nth_pset_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR, C_INT + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: n + INTEGER(KIND=C_INT), VALUE, INTENT(IN) :: pset_name_len + INTEGER, INTENT(INOUT) :: pset_len + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(OUT) :: pset_name + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_get_nth_pset_f + +subroutine ompi_session_get_num_psets_f(session, info, npset_names, ierror) & + BIND(C, name="ompi_session_get_num_psets_f") + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(out) :: npset_names + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_get_num_psets_f + +subroutine ompi_session_get_pset_info_f(session, pset_name, info, ierror, name_len) & + BIND(C, name="ompi_session_get_pset_info_f") + use, intrinsic :: ISO_C_BINDING, only : C_CHAR + implicit none + INTEGER, INTENT(IN) :: session + CHARACTER(KIND=C_CHAR), DIMENSION(*), INTENT(IN) :: pset_name + INTEGER, VALUE, INTENT(IN) :: name_len + INTEGER, INTENT(out) :: info + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_get_pset_info_f + +subroutine ompi_session_init_f(info, errhandler, session, ierror) & + BIND(C, name="ompi_session_init_f") + implicit none + INTEGER, INTENT(IN) :: info + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(out) :: session + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_init_f + +subroutine ompi_session_finalize_f(session, ierror) & + BIND(C, name="ompi_session_finalize_f") + implicit none + INTEGER, INTENT(out) :: session + INTEGER, INTENT(out) :: ierror +end subroutine ompi_session_finalize_f + +subroutine ompi_session_call_errhandler_f(session,errorcode,ierror) & + BIND(C, name="ompi_session_call_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(IN) :: errorcode + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_session_call_errhandler_f + + +subroutine ompi_session_create_errhandler_f(session_errhandler_fn,errhandler,ierror) & + BIND(C, name="ompi_session_create_errhandler_f") + use, intrinsic :: iso_c_binding, only: c_funptr + implicit none + type(c_funptr), value :: session_errhandler_fn + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_session_create_errhandler_f + +subroutine ompi_session_get_errhandler_f(session,errhandler,ierror) & + BIND(C, name="ompi_session_get_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(OUT) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_session_get_errhandler_f + +subroutine ompi_session_set_errhandler_f(session,errhandler,ierror) & + BIND(C, name="ompi_session_set_errhandler_f") + implicit none + INTEGER, INTENT(IN) :: session + INTEGER, INTENT(IN) :: errhandler + INTEGER, INTENT(OUT) :: ierror +end subroutine ompi_session_set_errhandler_f + + +end interface diff --git a/ompi/mpi/fortran/use-mpi-f08/compare_and_swap_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/compare_and_swap_f08.F90 index 07f9080087b..a1ef8935258 100644 --- a/ompi/mpi/fortran/use-mpi-f08/compare_and_swap_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/compare_and_swap_f08.F90 @@ -17,8 +17,8 @@ subroutine MPI_Compare_and_swap_f08(origin_addr,compare_addr,result_addr,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_compare_and_swap_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr, compare_addr - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr, compare_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr TYPE(MPI_Datatype), INTENT(IN) :: datatype INTEGER, INTENT(IN) :: target_rank INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/fetch_and_op_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/fetch_and_op_f08.F90 index 4958a4019ac..d71b9f3b22a 100644 --- a/ompi/mpi/fortran/use-mpi-f08/fetch_and_op_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/fetch_and_op_f08.F90 @@ -16,8 +16,8 @@ subroutine MPI_Fetch_and_op_f08(origin_addr,result_addr,datatype,target_rank, & use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_fetch_and_op_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr TYPE(MPI_Datatype), INTENT(IN) :: datatype INTEGER, INTENT(IN) :: target_rank INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/get_accumulate_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/get_accumulate_f08.F90 index 9fd4f2ead5b..19d0bb4b1ad 100644 --- a/ompi/mpi/fortran/use-mpi-f08/get_accumulate_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/get_accumulate_f08.F90 @@ -18,10 +18,10 @@ subroutine MPI_Get_accumulate_f08(origin_addr,origin_count,origin_datatype,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_get_accumulate_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, result_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr TYPE(MPI_Datatype), INTENT(IN) :: result_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp TYPE(MPI_Datatype), INTENT(IN) :: target_datatype diff --git a/ompi/mpi/fortran/use-mpi-f08/get_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/get_f08.F90 index a51ca425ccd..15821aa8a99 100644 --- a/ompi/mpi/fortran/use-mpi-f08/get_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/get_f08.F90 @@ -16,7 +16,7 @@ subroutine MPI_Get_f08(origin_addr,origin_count,origin_datatype,target_rank,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_get_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in index 46161939812..ee19d807ba5 100644 --- a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in +++ b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-interfaces.h.in @@ -3173,7 +3173,7 @@ end subroutine MPI_Unpublish_name_f08 end interface MPI_Unpublish_name interface MPI_Accumulate -subroutine MPI_Accumulate_f08(origin_addr,origin_count,origin_datatype,target_rank, & +subroutine MPI_Accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & target_disp,target_count,target_datatype,op,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND implicit none @@ -3186,11 +3186,11 @@ subroutine MPI_Accumulate_f08(origin_addr,origin_count,origin_datatype,target_ra TYPE(MPI_Op), INTENT(IN) :: op TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Accumulate_f08 +end subroutine MPI_Accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Accumulate interface MPI_Raccumulate -subroutine MPI_Raccumulate_f08(origin_addr,origin_count,origin_datatype,target_rank, & +subroutine MPI_Raccumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & target_disp,target_count,target_datatype,op,win,request, & ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_Request, MPI_ADDRESS_KIND @@ -3205,12 +3205,12 @@ subroutine MPI_Raccumulate_f08(origin_addr,origin_count,origin_datatype,target_r TYPE(MPI_Win), INTENT(IN) :: win TYPE(MPI_Request), INTENT(OUT) :: request INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Raccumulate_f08 +end subroutine MPI_Raccumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Raccumulate interface MPI_Get -subroutine MPI_Get_f08(origin_addr,origin_count,origin_datatype,target_rank, & - target_disp,target_count,target_datatype,win,ierror) +subroutine MPI_Get_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND implicit none @OMPI_FORTRAN_IGNORE_TKR_PREDECL@ origin_addr @@ -3221,11 +3221,11 @@ subroutine MPI_Get_f08(origin_addr,origin_count,origin_datatype,target_rank, & TYPE(MPI_Datatype), INTENT(IN) :: target_datatype TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Get_f08 +end subroutine MPI_Get_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Get interface MPI_Rget -subroutine MPI_Rget_f08(origin_addr,origin_count,origin_datatype,target_rank, & +subroutine MPI_Rget_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & target_disp,target_count,target_datatype,win,request,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Request, MPI_Win, MPI_ADDRESS_KIND implicit none @@ -3238,11 +3238,11 @@ subroutine MPI_Rget_f08(origin_addr,origin_count,origin_datatype,target_rank, & TYPE(MPI_Win), INTENT(IN) :: win TYPE(MPI_Request), INTENT(OUT) :: request INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Rget_f08 +end subroutine MPI_Rget_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Rget interface MPI_Get_accumulate -subroutine MPI_Get_accumulate_f08(origin_addr,origin_count,origin_datatype,result_addr, & +subroutine MPI_Get_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,result_addr, & result_count,result_datatype,target_rank,target_disp, & target_count,target_datatype,op,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND @@ -3258,11 +3258,11 @@ subroutine MPI_Get_accumulate_f08(origin_addr,origin_count,origin_datatype,resul TYPE(MPI_Op), INTENT(IN) :: op TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Get_accumulate_f08 +end subroutine MPI_Get_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Get_accumulate interface MPI_Rget_accumulate -subroutine MPI_Rget_accumulate_f08(origin_addr,origin_count,origin_datatype,result_addr, & +subroutine MPI_Rget_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,result_addr, & result_count,result_datatype,target_rank,target_disp, & target_count,target_datatype,op,win,request,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Request, MPI_Win, MPI_ADDRESS_KIND @@ -3279,12 +3279,12 @@ subroutine MPI_Rget_accumulate_f08(origin_addr,origin_count,origin_datatype,resu TYPE(MPI_Win), INTENT(IN) :: win TYPE(MPI_Request), INTENT(OUT) :: request INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Rget_accumulate_f08 +end subroutine MPI_Rget_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Rget_accumulate interface MPI_Put -subroutine MPI_Put_f08(origin_addr,origin_count,origin_datatype,target_rank, & - target_disp,target_count,target_datatype,win,ierror) +subroutine MPI_Put_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & + target_disp,target_count,target_datatype,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND implicit none @OMPI_FORTRAN_IGNORE_TKR_PREDECL@ origin_addr @@ -3295,11 +3295,11 @@ subroutine MPI_Put_f08(origin_addr,origin_count,origin_datatype,target_rank, & TYPE(MPI_Datatype), INTENT(IN) :: target_datatype TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Put_f08 +end subroutine MPI_Put_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Put interface MPI_Rput -subroutine MPI_Rput_f08(origin_addr,origin_count,origin_datatype,target_rank, & +subroutine MPI_Rput_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,origin_count,origin_datatype,target_rank, & target_disp,target_count,target_datatype,win,request,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_Request, MPI_ADDRESS_KIND implicit none @@ -3312,11 +3312,11 @@ subroutine MPI_Rput_f08(origin_addr,origin_count,origin_datatype,target_rank, & TYPE(MPI_Win), INTENT(IN) :: win TYPE(MPI_Request), INTENT(OUT) :: request INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Rput_f08 +end subroutine MPI_Rput_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Rput interface MPI_Fetch_and_op -subroutine MPI_Fetch_and_op_f08(origin_addr,result_addr,datatype,target_rank, & +subroutine MPI_Fetch_and_op_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,result_addr,datatype,target_rank, & target_disp,op,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_ADDRESS_KIND implicit none @@ -3329,11 +3329,11 @@ subroutine MPI_Fetch_and_op_f08(origin_addr,result_addr,datatype,target_rank, & TYPE(MPI_Op), INTENT(IN) :: op TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Fetch_and_op_f08 +end subroutine MPI_Fetch_and_op_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Fetch_and_op interface MPI_Compare_and_swap -subroutine MPI_Compare_and_swap_f08(origin_addr,compare_addr,result_addr,datatype, & +subroutine MPI_Compare_and_swap_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(origin_addr,compare_addr,result_addr,datatype, & target_rank,target_disp,win,ierror) use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND implicit none @@ -3345,7 +3345,7 @@ subroutine MPI_Compare_and_swap_f08(origin_addr,compare_addr,result_addr,datatyp INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Compare_and_swap_f08 +end subroutine MPI_Compare_and_swap_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Compare_and_swap interface MPI_Win_complete @@ -3358,7 +3358,7 @@ end subroutine MPI_Win_complete_f08 end interface MPI_Win_complete interface MPI_Win_create -subroutine MPI_Win_create_f08(base,size,disp_unit,info,comm,win,ierror) +subroutine MPI_Win_create_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(base,size,disp_unit,info,comm,win,ierror) use :: mpi_f08_types, only : MPI_Info, MPI_Comm, MPI_Win, MPI_ADDRESS_KIND implicit none @OMPI_FORTRAN_IGNORE_TKR_PREDECL@ base @@ -3369,7 +3369,7 @@ subroutine MPI_Win_create_f08(base,size,disp_unit,info,comm,win,ierror) TYPE(MPI_Comm), INTENT(IN) :: comm TYPE(MPI_Win), INTENT(OUT) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Win_create_f08 +end subroutine MPI_Win_create_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Win_create interface MPI_Win_create_dynamic @@ -3384,7 +3384,7 @@ end subroutine MPI_Win_create_dynamic_f08 end interface MPI_Win_create_dynamic interface MPI_Win_attach -subroutine MPI_Win_attach_f08(win,base,size,ierror) +subroutine MPI_Win_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(win,base,size,ierror) use :: mpi_f08_types, only : MPI_Win, MPI_ADDRESS_KIND implicit none @OMPI_FORTRAN_IGNORE_TKR_PREDECL@ base @@ -3392,18 +3392,18 @@ subroutine MPI_Win_attach_f08(win,base,size,ierror) INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Win_attach_f08 +end subroutine MPI_Win_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Win_attach interface MPI_Win_detach -subroutine MPI_Win_detach_f08(win,base,ierror) +subroutine MPI_Win_detach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@(win,base,ierror) use :: mpi_f08_types, only : MPI_Win, MPI_ADDRESS_KIND implicit none @OMPI_FORTRAN_IGNORE_TKR_PREDECL@ base @OMPI_FORTRAN_IGNORE_TKR_TYPE@ OMPI_ASYNCHRONOUS :: base TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror -end subroutine MPI_Win_detach_f08 +end subroutine MPI_Win_detach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ end interface MPI_Win_detach interface MPI_Win_fence diff --git a/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h.in b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h.in new file mode 100644 index 00000000000..9ea9efc8999 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/mod/mpi-f08-rename.h.in @@ -0,0 +1,967 @@ +! -*- f90 -*- +! +! Copyright (c) 2019-2020 Research Organization for Information Science +! and Technology (RIST). All rights reserved. + +#if OMPI_BUILD_MPI_PROFILING + +#define MPI_Bsend PMPI_Bsend +#define MPI_Bsend_f08 PMPI_Bsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Bsend_f08ts PMPI_Bsend_f08ts +#define MPI_Bsend_init PMPI_Bsend_init +#define MPI_Bsend_init_f08 PMPI_Bsend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Bsend_init_f08ts PMPI_Bsend_init_f08ts +#define MPI_Buffer_attach PMPI_Buffer_attach +#define MPI_Buffer_attach_f08 PMPI_Buffer_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Buffer_attach_f08ts PMPI_Buffer_attach_f08ts +#define MPI_Buffer_detach PMPI_Buffer_detach +#define MPI_Buffer_detach_f08 PMPI_Buffer_detach_f08 +#define MPI_Cancel PMPI_Cancel +#define MPI_Cancel_f08 PMPI_Cancel_f08 +#define MPI_Get_count PMPI_Get_count +#define MPI_Get_count_f08 PMPI_Get_count_f08 +#define MPI_Ibsend PMPI_Ibsend +#define MPI_Ibsend_f08 PMPI_Ibsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ibsend_f08ts PMPI_Ibsend_f08ts +#define MPI_Iprobe PMPI_Iprobe +#define MPI_Iprobe_f08 PMPI_Iprobe_f08 +#define MPI_Irecv PMPI_Irecv +#define MPI_Irecv_f08 PMPI_Irecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Irecv_f08ts PMPI_Irecv_f08ts +#define MPI_Irsend PMPI_Irsend +#define MPI_Irsend_f08 PMPI_Irsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Irsend_f08ts PMPI_Irsend_f08ts +#define MPI_Isend PMPI_Isend +#define MPI_Isend_f08 PMPI_Isend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Isend_f08ts PMPI_Isend_f08ts +#define MPI_Issend PMPI_Issend +#define MPI_Issend_f08 PMPI_Issend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Issend_f08ts PMPI_Issend_f08ts +#define MPI_Precv_init PMPI_Precv_init +#define MPI_Precv_init_f08 PMPI_Precv_init_f08 +#define MPI_Psend_init PMPI_Psend_init +#define MPI_Psend_init_f08 PMPI_Psend_init_f08 +#define MPI_Pready PMPI_Pready +#define MPI_Pready_f08 PMPI_Pready_f08 +#define MPI_Pready_list PMPI_Pready_list +#define MPI_Pready_list_f08 PMPI_Pready_list_f08 +#define MPI_Pready_range PMPI_Pready_range +#define MPI_Pready_range_f08 PMPI_Pready_range_f08 +#define MPI_Parrived PMPI_Parrived +#define MPI_Parrived_f08 PMPI_Parrived_f08 +#define MPI_Probe PMPI_Probe +#define MPI_Probe_f08 PMPI_Probe_f08 +#define MPI_Recv PMPI_Recv +#define MPI_Recv_f08 PMPI_Recv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Recv_f08ts PMPI_Recv_f08ts +#define MPI_Recv_init PMPI_Recv_init +#define MPI_Recv_init_f08 PMPI_Recv_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Recv_init_f08ts PMPI_Recv_init_f08ts +#define MPI_Request_free PMPI_Request_free +#define MPI_Request_free_f08 PMPI_Request_free_f08 +#define MPI_Request_get_status PMPI_Request_get_status +#define MPI_Request_get_status_f08 PMPI_Request_get_status_f08 +#define MPI_Rsend PMPI_Rsend +#define MPI_Rsend_f08 PMPI_Rsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rsend_f08ts PMPI_Rsend_f08ts +#define MPI_Rsend_init PMPI_Rsend_init +#define MPI_Rsend_init_f08 PMPI_Rsend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rsend_init_f08ts PMPI_Rsend_init_f08ts +#define MPI_Send PMPI_Send +#define MPI_Send_f08 PMPI_Send_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Send_f08ts PMPI_Send_f08ts +#define MPI_Sendrecv PMPI_Sendrecv +#define MPI_Sendrecv_f08 PMPI_Sendrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Sendrecv_f08ts PMPI_Sendrecv_f08ts +#define MPI_Sendrecv_replace PMPI_Sendrecv_replace +#define MPI_Sendrecv_replace_f08 PMPI_Sendrecv_replace_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Sendrecv_replace_f08ts PMPI_Sendrecv_replace_f08ts +#define MPI_Send_init PMPI_Send_init +#define MPI_Send_init_f08 PMPI_Send_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Send_init_f08ts PMPI_Send_init_f08ts +#define MPI_Session_call_errhandler PMPI_Session_call_errhandler +#define MPI_Session_call_errhandler_f08 PMPI_Session_call_errhandler_f08 +#define MPI_Session_create_errhandler PMPI_Session_create_errhandler +#define MPI_Session_create_errhandler_f08 PMPI_Session_create_errhandler_f08 +#define MPI_Session_get_errhandler PMPI_Session_get_errhandler +#define MPI_Session_get_errhandler_f08 PMPI_Session_get_errhandler_f08 +#define MPI_Session_get_info PMPI_Session_get_info +#define MPI_Session_get_info_f08 PMPI_Session_get_info_f08 +#define MPI_Session_get_nth_pset PMPI_Session_get_nth_pset +#define MPI_Session_get_nth_pset_f08 PMPI_Session_get_nth_pset_f08 +#define MPI_Session_get_nth_psetlen PMPI_Session_get_nth_psetlen +#define MPI_Session_get_nth_psetlen_f08 PMPI_Session_get_nth_psetlen_f08 +#define MPI_Session_get_num_psets PMPI_Session_get_num_psets +#define MPI_Session_get_num_psets_f08 PMPI_Session_get_num_psets_f08 +#define MPI_Session_get_pset_info PMPI_Session_get_pset_info +#define MPI_Session_get_pset_info_f08 PMPI_Session_get_pset_info_f08 +#define MPI_Session_init PMPI_Session_init +#define MPI_Session_init_f08 PMPI_Session_init_f08 +#define MPI_Session_finalize PMPI_Session_finalize +#define MPI_Session_finalize_f08 PMPI_Session_finalize_f08 +#define MPI_Session_set_errhandler PMPI_Session_set_errhandler +#define MPI_Session_set_errhandler_f08 PMPI_Session_set_errhandler_f08 +#define MPI_Ssend PMPI_Ssend +#define MPI_Ssend_f08 PMPI_Ssend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ssend_f08ts PMPI_Ssend_f08ts +#define MPI_Ssend_init PMPI_Ssend_init +#define MPI_Ssend_init_f08 PMPI_Ssend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ssend_init_f08ts PMPI_Ssend_init_f08ts +#define MPI_Start PMPI_Start +#define MPI_Start_f08 PMPI_Start_f08 +#define MPI_Startall PMPI_Startall +#define MPI_Startall_f08 PMPI_Startall_f08 +#define MPI_Test PMPI_Test +#define MPI_Test_f08 PMPI_Test_f08 +#define MPI_Testall PMPI_Testall +#define MPI_Testall_f08 PMPI_Testall_f08 +#define MPI_Testany PMPI_Testany +#define MPI_Testany_f08 PMPI_Testany_f08 +#define MPI_Testsome PMPI_Testsome +#define MPI_Testsome_f08 PMPI_Testsome_f08 +#define MPI_Test_cancelled PMPI_Test_cancelled +#define MPI_Test_cancelled_f08 PMPI_Test_cancelled_f08 +#define MPI_Wait PMPI_Wait +#define MPI_Wait_f08 PMPI_Wait_f08 +#define MPI_Waitall PMPI_Waitall +#define MPI_Waitall_f08 PMPI_Waitall_f08 +#define MPI_Waitany PMPI_Waitany +#define MPI_Waitany_f08 PMPI_Waitany_f08 +#define MPI_Waitsome PMPI_Waitsome +#define MPI_Waitsome_f08 PMPI_Waitsome_f08 +#define MPI_Get_address PMPI_Get_address +#define MPI_Get_address_f08 PMPI_Get_address_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_address_f08ts PMPI_Get_address_f08ts +#define MPI_Get_elements PMPI_Get_elements +#define MPI_Get_elements_f08 PMPI_Get_elements_f08 +#define MPI_Get_elements_x PMPI_Get_elements_x +#define MPI_Get_elements_x_f08 PMPI_Get_elements_x_f08 +#define MPI_Pack PMPI_Pack +#define MPI_Pack_f08 PMPI_Pack_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Pack_f08ts PMPI_Pack_f08s +#define MPI_Pack_external PMPI_Pack_external +#define MPI_Pack_external_f08 PMPI_Pack_external_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Pack_external_f08ts PMPI_Pack_external_f08ts +#define MPI_Pack_external_size PMPI_Pack_external_size +#define MPI_Pack_external_size_f08 PMPI_Pack_external_size_f08 +#define MPI_Pack_size PMPI_Pack_size +#define MPI_Pack_size_f08 PMPI_Pack_size_f08 +#define MPI_Type_commit PMPI_Type_commit +#define MPI_Type_commit_f08 PMPI_Type_commit_f08 +#define MPI_Type_contiguous PMPI_Type_contiguous +#define MPI_Type_contiguous_f08 PMPI_Type_contiguous_f08 +#define MPI_Type_create_darray PMPI_Type_create_darray +#define MPI_Type_create_darray_f08 PMPI_Type_create_darray_f08 +#define MPI_Type_create_hindexed PMPI_Type_create_hindexed +#define MPI_Type_create_hindexed_f08 PMPI_Type_create_hindexed_f08 +#define MPI_Type_create_hvector PMPI_Type_create_hvector +#define MPI_Type_create_hvector_f08 PMPI_Type_create_hvector_f08 +#define MPI_Type_create_indexed_block PMPI_Type_create_indexed_block +#define MPI_Type_create_indexed_block_f08 PMPI_Type_create_indexed_block_f08 +#define MPI_Type_create_hindexed_block PMPI_Type_create_hindexed_block +#define MPI_Type_create_hindexed_block_f08 PMPI_Type_create_hindexed_block_f08 +#define MPI_Type_create_resized PMPI_Type_create_resized +#define MPI_Type_create_resized_f08 PMPI_Type_create_resized_f08 +#define MPI_Type_create_struct PMPI_Type_create_struct +#define MPI_Type_create_struct_f08 PMPI_Type_create_struct_f08 +#define MPI_Type_create_subarray PMPI_Type_create_subarray +#define MPI_Type_create_subarray_f08 PMPI_Type_create_subarray_f08 +#define MPI_Type_dup PMPI_Type_dup +#define MPI_Type_dup_f08 PMPI_Type_dup_f08 +#define MPI_Type_free PMPI_Type_free +#define MPI_Type_free_f08 PMPI_Type_free_f08 +#define MPI_Type_get_contents PMPI_Type_get_contents +#define MPI_Type_get_contents_f08 PMPI_Type_get_contents_f08 +#define MPI_Type_get_envelope PMPI_Type_get_envelope +#define MPI_Type_get_envelope_f08 PMPI_Type_get_envelope_f08 +#define MPI_Type_get_extent PMPI_Type_get_extent +#define MPI_Type_get_extent_f08 PMPI_Type_get_extent_f08 +#define MPI_Type_get_extent_x PMPI_Type_get_extent_x +#define MPI_Type_get_extent_x_f08 PMPI_Type_get_extent_x_f08 +#define MPI_Type_get_true_extent PMPI_Type_get_true_extent +#define MPI_Type_get_true_extent_f08 PMPI_Type_get_true_extent_f08 +#define MPI_Type_get_true_extent_x PMPI_Type_get_true_extent_x +#define MPI_Type_get_true_extent_x_f08 PMPI_Type_get_true_extent_x_f08 +#define MPI_Type_indexed PMPI_Type_indexed +#define MPI_Type_indexed_f08 PMPI_Type_indexed_f08 +#define MPI_Type_size PMPI_Type_size +#define MPI_Type_size_f08 PMPI_Type_size_f08 +#define MPI_Type_size_x PMPI_Type_size_x +#define MPI_Type_size_x_f08 PMPI_Type_size_x_f08 +#define MPI_Type_vector PMPI_Type_vector +#define MPI_Type_vector_f08 PMPI_Type_vector_f08 +#define MPI_Unpack PMPI_Unpack +#define MPI_Unpack_f08 PMPI_Unpack_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Unpack_f08ts PMPI_Unpack_f08ts +#define MPI_Unpack_external PMPI_Unpack_external +#define MPI_Unpack_external_f08 PMPI_Unpack_external_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Unpack_external_f08ts PMPI_Unpack_external_f08ts +#define MPI_Allgather PMPI_Allgather +#define MPI_Allgather_f08 PMPI_Allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allgather_f08ts PMPI_Allgather_f08ts +#define MPI_Iallgather PMPI_Iallgather +#define MPI_Iallgather_f08 PMPI_Iallgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallgather_f08ts PMPI_Iallgather_f08ts +#define MPI_Allgather_init PMPI_Allgather_init +#define MPI_Allgather_init_f08 PMPI_Allgather_init_f08 +#define MPI_Allgatherv PMPI_Allgatherv +#define MPI_Allgatherv_f08 PMPI_Allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allgatherv_f08ts PMPI_Allgatherv_f08ts +#define MPI_Iallgatherv PMPI_Iallgatherv +#define MPI_Iallgatherv_f08 PMPI_Iallgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallgatherv_f08ts PMPI_Iallgatherv_f08ts +#define MPI_Allgatherv_init PMPI_Allgatherv_init +#define MPI_Allgatherv_init_f08 PMPI_Allgatherv_init_f08 +#define MPI_Allreduce PMPI_Allreduce +#define MPI_Allreduce_f08 PMPI_Allreduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allreduce_f08ts PMPI_Allreduce_f08ts +#define MPI_Iallreduce PMPI_Iallreduce +#define MPI_Iallreduce_f08 PMPI_Iallreduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallreduce_f08ts PMPI_Iallreduce_f08ts +#define MPI_Allreduce_init PMPI_Allreduce_init +#define MPI_Allreduce_init_f08 PMPI_Allreduce_init_f08 +#define MPI_Alltoall PMPI_Alltoall +#define MPI_Alltoall_f08 PMPI_Alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoall_f08ts PMPI_Alltoall_f08ts +#define MPI_Ialltoall PMPI_Ialltoall +#define MPI_Ialltoall_f08 PMPI_Ialltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoall_f08ts PMPI_Ialltoall_f08ts +#define MPI_Alltoall_init PMPI_Alltoall_init +#define MPI_Alltoall_init_f08 PMPI_Alltoall_init_f08 +#define MPI_Alltoallv PMPI_Alltoallv +#define MPI_Alltoallv_f08 PMPI_Alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoallv_f08ts PMPI_Alltoallv_f08ts +#define MPI_Ialltoallv PMPI_Ialltoallv +#define MPI_Ialltoallv_f08 PMPI_Ialltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoallv_f08ts PMPI_Ialltoallv_f08ts +#define MPI_Alltoallv_init PMPI_Alltoallv_init +#define MPI_Alltoallv_init_f08 PMPI_Alltoallv_init_f08 +#define MPI_Alltoallw PMPI_Alltoallw +#define MPI_Alltoallw_f08 PMPI_Alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoallw_f08ts PMPI_Alltoallw_f08ts +#define MPI_Ialltoallw PMPI_Ialltoallw +#define MPI_Ialltoallw_f08 PMPI_Ialltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoallw_f08ts PMPI_Ialltoallw_f08ts +#define MPI_Alltoallw_init PMPI_Alltoallw_init +#define MPI_Alltoallw_init_f08 PMPI_Alltoallw_init_f08 +#define MPI_Barrier PMPI_Barrier +#define MPI_Barrier_f08 PMPI_Barrier_f08 +#define MPI_Ibarrier PMPI_Ibarrier +#define MPI_Ibarrier_f08 PMPI_Ibarrier_f08 +#define MPI_Barrier_init PMPI_Barrier_init +#define MPI_Barrier_init_f08 PMPI_Barrier_init_f08 +#define MPI_Bcast PMPI_Bcast +#define MPI_Bcast_f08 PMPI_Bcast_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Bcast_f08ts PMPI_Bcast_f08ts +#define MPI_Ibcast PMPI_Ibcast +#define MPI_Ibcast_f08 PMPI_Ibcast_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ibcast_f08ts PMPI_Ibcast_f08ts +#define MPI_Bcast_init PMPI_Bcast_init +#define MPI_Bcast_init_f08 PMPI_Bcast_init_f08 +#define MPI_Exscan PMPI_Exscan +#define MPI_Exscan_f08 PMPI_Exscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Exscan_f08ts PMPI_Exscan_f08ts +#define MPI_Iexscan PMPI_Iexscan +#define MPI_Iexscan_f08 PMPI_Iexscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iexscan_f08ts PMPI_Iexscan_f08ts +#define MPI_Exscan_init PMPI_Exscan_init +#define MPI_Exscan_init_f08 PMPI_Exscan_init_f08 +#define MPI_Gather PMPI_Gather +#define MPI_Gather_f08 PMPI_Gather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Gather_f08ts PMPI_Gather_f08ts +#define MPI_Igather PMPI_Igather +#define MPI_Igather_f08 PMPI_Igather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Igather_f08ts PMPI_Igather_f08ts +#define MPI_Gather_init PMPI_Gather_init +#define MPI_Gather_init_f08 PMPI_Gather_init_f08 +#define MPI_Gatherv PMPI_Gatherv +#define MPI_Gatherv_f08 PMPI_Gatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Gatherv_f08ts PMPI_Gatherv_f08ts +#define MPI_Igatherv PMPI_Igatherv +#define MPI_Igatherv_f08 PMPI_Igatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Igatherv_f08ts PMPI_Igatherv_f08ts +#define MPI_Gatherv_init PMPI_Gatherv_init +#define MPI_Gatherv_init_f08 PMPI_Gatherv_init_f08 +#define MPI_Op_commutative PMPI_Op_commutative +#define MPI_Op_commutative_f08 PMPI_Op_commutative_f08 +#define MPI_Op_create PMPI_Op_create +#define MPI_Op_create_f08 PMPI_Op_create_f08 +#define MPI_Op_free PMPI_Op_free +#define MPI_Op_free_f08 PMPI_Op_free_f08 +#define MPI_Reduce PMPI_Reduce +#define MPI_Reduce_f08 PMPI_Reduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_f08ts PMPI_Reduce_f08ts +#define MPI_Ireduce PMPI_Ireduce +#define MPI_Ireduce_f08 PMPI_Ireduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_f08ts PMPI_Ireduce_f08ts +#define MPI_Reduce_init PMPI_Reduce_init +#define MPI_Reduce_init_f08 PMPI_Reduce_init_f08 +#define MPI_Reduce_local PMPI_Reduce_local +#define MPI_Reduce_local_f08 PMPI_Reduce_local_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_local_f08ts PMPI_Reduce_local_f08ts +#define MPI_Reduce_scatter PMPI_Reduce_scatter +#define MPI_Reduce_scatter_f08 PMPI_Reduce_scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_scatter_f08ts PMPI_Reduce_scatter_f08ts +#define MPI_Ireduce_scatter PMPI_Ireduce_scatter +#define MPI_Ireduce_scatter_f08 PMPI_Ireduce_scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_scatter_f08ts PMPI_Ireduce_scatter_f08ts +#define MPI_Reduce_scatter_init PMPI_Reduce_scatter_init +#define MPI_Reduce_scatter_init_f08 PMPI_Reduce_scatter_init_f08 +#define MPI_Reduce_scatter_block PMPI_Reduce_scatter_block +#define MPI_Reduce_scatter_block_f08 PMPI_Reduce_scatter_block_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_scatter_block_f08ts PMPI_Reduce_scatter_block_f08ts +#define MPI_Ireduce_scatter_block PMPI_Ireduce_scatter_block +#define MPI_Ireduce_scatter_block_f08 PMPI_Ireduce_scatter_block_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_scatter_block_f08ts PMPI_Ireduce_scatter_block_f08ts +#define MPI_Reduce_scatter_block_init PMPI_Reduce_scatter_block_init +#define MPI_Reduce_scatter_block_init_f08 PMPI_Reduce_scatter_block_init_f08 +#define MPI_Scan PMPI_Scan +#define MPI_Scan_f08 PMPI_Scan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scan_f08ts PMPI_Scan_f08ts +#define MPI_Iscan PMPI_Iscan +#define MPI_Iscan_f08 PMPI_Iscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscan_f08ts PMPI_Iscan_f08ts +#define MPI_Scan_init PMPI_Scan_init +#define MPI_Scan_init_f08 PMPI_Scan_init_f08 +#define MPI_Scatter PMPI_Scatter +#define MPI_Scatter_f08 PMPI_Scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scatter_f08ts PMPI_Scatter_f08ts +#define MPI_Iscatter PMPI_Iscatter +#define MPI_Iscatter_f08 PMPI_Iscatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscatter_f08ts PMPI_Iscatter_f08ts +#define MPI_Scatter_init PMPI_Scatter_init +#define MPI_Scatter_init_f08 PMPI_Scatter_init_f08 +#define MPI_Scatterv PMPI_Scatterv +#define MPI_Scatterv_f08 PMPI_Scatterv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scatterv_f08ts PMPI_Scatterv_f08ts +#define MPI_Iscatterv PMPI_Iscatterv +#define MPI_Iscatterv_f08 PMPI_Iscatterv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscatterv_f08ts PMPI_Iscatterv_f08ts +#define MPI_Scatterv_init PMPI_Scatterv_init +#define MPI_Scatterv_init_f08 PMPI_Scatterv_init_f08 +#define MPI_Comm_compare PMPI_Comm_compare +#define MPI_Comm_compare_f08 PMPI_Comm_compare_f08 +#define MPI_Comm_create PMPI_Comm_create +#define MPI_Comm_create_f08 PMPI_Comm_create_f08 +#define MPI_Comm_create_group PMPI_Comm_create_group +#define MPI_Comm_create_group_f08 PMPI_Comm_create_group_f08 +#define MPI_Comm_create_from_group PMPI_Comm_create_from_group +#define MPI_Comm_create_from_group_f08 PMPI_Comm_create_from_group_f08 +#define MPI_Comm_create_keyval PMPI_Comm_create_keyval +#define MPI_Comm_create_keyval_f08 PMPI_Comm_create_keyval_f08 +#define MPI_Comm_delete_attr PMPI_Comm_delete_attr +#define MPI_Comm_delete_attr_f08 PMPI_Comm_delete_attr_f08 +#define MPI_Comm_dup PMPI_Comm_dup +#define MPI_Comm_dup_f08 PMPI_Comm_dup_f08 +#define MPI_Comm_dup_with_info PMPI_Comm_dup_with_info +#define MPI_Comm_dup_with_info_f08 PMPI_Comm_dup_with_info_f08 +#define MPI_Comm_idup PMPI_Comm_idup +#define MPI_Comm_idup_f08 PMPI_Comm_idup_f08 +#define MPI_Comm_idup_with_info PMPI_Comm_idup_with_info +#define MPI_Comm_idup_with_info_f08 PMPI_Comm_idup_with_info_f08 +#define MPI_Comm_free PMPI_Comm_free +#define MPI_Comm_free_f08 PMPI_Comm_free_f08 +#define MPI_Comm_free_keyval PMPI_Comm_free_keyval +#define MPI_Comm_free_keyval_f08 PMPI_Comm_free_keyval_f08 +#define MPI_Comm_get_attr PMPI_Comm_get_attr +#define MPI_Comm_get_attr_f08 PMPI_Comm_get_attr_f08 +#define MPI_Comm_get_info PMPI_Comm_get_info +#define MPI_Comm_get_info_f08 PMPI_Comm_get_info_f08 +#define MPI_Comm_get_name PMPI_Comm_get_name +#define MPI_Comm_get_name_f08 PMPI_Comm_get_name_f08 +#define MPI_Comm_group PMPI_Comm_group +#define MPI_Comm_group_f08 PMPI_Comm_group_f08 +#define MPI_Comm_rank PMPI_Comm_rank +#define MPI_Comm_rank_f08 PMPI_Comm_rank_f08 +#define MPI_Comm_remote_group PMPI_Comm_remote_group +#define MPI_Comm_remote_group_f08 PMPI_Comm_remote_group_f08 +#define MPI_Comm_remote_size PMPI_Comm_remote_size +#define MPI_Comm_remote_size_f08 PMPI_Comm_remote_size_f08 +#define MPI_Comm_set_attr PMPI_Comm_set_attr +#define MPI_Comm_set_attr_f08 PMPI_Comm_set_attr_f08 +#define MPI_Comm_set_info PMPI_Comm_set_info +#define MPI_Comm_set_info_f08 PMPI_Comm_set_info_f08 +#define MPI_Comm_set_name PMPI_Comm_set_name +#define MPI_Comm_set_name_f08 PMPI_Comm_set_name_f08 +#define MPI_Comm_size PMPI_Comm_size +#define MPI_Comm_size_f08 PMPI_Comm_size_f08 +#define MPI_Comm_split PMPI_Comm_split +#define MPI_Comm_split_f08 PMPI_Comm_split_f08 +#define MPI_Comm_test_inter PMPI_Comm_test_inter +#define MPI_Comm_test_inter_f08 PMPI_Comm_test_inter_f08 +#define MPI_Group_compare PMPI_Group_compare +#define MPI_Group_compare_f08 PMPI_Group_compare_f08 +#define MPI_Group_difference PMPI_Group_difference +#define MPI_Group_difference_f08 PMPI_Group_difference_f08 +#define MPI_Group_excl PMPI_Group_excl +#define MPI_Group_excl_f08 PMPI_Group_excl_f08 +#define MPI_Group_from_session_pset PMPI_Group_from_session_pset +#define MPI_Group_from_session_pset_f08 PMPI_Group_from_session_pset_f08 +#define MPI_Group_free PMPI_Group_free +#define MPI_Group_free_f08 PMPI_Group_free_f08 +#define MPI_Group_incl PMPI_Group_incl +#define MPI_Group_incl_f08 PMPI_Group_incl_f08 +#define MPI_Group_intersection PMPI_Group_intersection +#define MPI_Group_intersection_f08 PMPI_Group_intersection_f08 +#define MPI_Group_range_excl PMPI_Group_range_excl +#define MPI_Group_range_excl_f08 PMPI_Group_range_excl_f08 +#define MPI_Group_range_incl PMPI_Group_range_incl +#define MPI_Group_range_incl_f08 PMPI_Group_range_incl_f08 +#define MPI_Group_rank PMPI_Group_rank +#define MPI_Group_rank_f08 PMPI_Group_rank_f08 +#define MPI_Group_size PMPI_Group_size +#define MPI_Group_size_f08 PMPI_Group_size_f08 +#define MPI_Group_translate_ranks PMPI_Group_translate_ranks +#define MPI_Group_translate_ranks_f08 PMPI_Group_translate_ranks_f08 +#define MPI_Group_union PMPI_Group_union +#define MPI_Group_union_f08 PMPI_Group_union_f08 +#define MPI_Intercomm_create PMPI_Intercomm_create +#define MPI_Intercomm_create_f08 PMPI_Intercomm_create_f08 +#define MPI_Intercomm_create_from_groups PMPI_Intercomm_create_from_groups +#define MPI_Intercomm_create_from_groups_f08 PMPI_Intercomm_create_from_groups_f08 +#define MPI_Intercomm_merge PMPI_Intercomm_merge +#define MPI_Intercomm_merge_f08 PMPI_Intercomm_merge_f08 +#define MPI_Type_create_keyval PMPI_Type_create_keyval +#define MPI_Type_create_keyval_f08 PMPI_Type_create_keyval_f08 +#define MPI_Type_delete_attr PMPI_Type_delete_attr +#define MPI_Type_delete_attr_f08 PMPI_Type_delete_attr_f08 +#define MPI_Type_free_keyval PMPI_Type_free_keyval +#define MPI_Type_free_keyval_f08 PMPI_Type_free_keyval_f08 +#define MPI_Type_get_attr PMPI_Type_get_attr +#define MPI_Type_get_attr_f08 PMPI_Type_get_attr_f08 +#define MPI_Type_get_name PMPI_Type_get_name +#define MPI_Type_get_name_f08 PMPI_Type_get_name_f08 +#define MPI_Type_set_attr PMPI_Type_set_attr +#define MPI_Type_set_attr_f08 PMPI_Type_set_attr_f08 +#define MPI_Type_set_name PMPI_Type_set_name +#define MPI_Type_set_name_f08 PMPI_Type_set_name_f08 +#define MPI_Win_allocate PMPI_Win_allocate +#define MPI_Win_allocate_f08 PMPI_Win_allocate_f08 +#define MPI_Win_allocate_shared PMPI_Win_allocate_shared +#define MPI_Win_allocate_shared_f08 PMPI_Win_allocate_shared_f08 +#define MPI_Win_create_keyval PMPI_Win_create_keyval +#define MPI_Win_create_keyval_f08 PMPI_Win_create_keyval_f08 +#define MPI_Win_delete_attr PMPI_Win_delete_attr +#define MPI_Win_delete_attr_f08 PMPI_Win_delete_attr_f08 +#define MPI_Win_free_keyval PMPI_Win_free_keyval +#define MPI_Win_free_keyval_f08 PMPI_Win_free_keyval_f08 +#define MPI_Win_get_attr PMPI_Win_get_attr +#define MPI_Win_get_attr_f08 PMPI_Win_get_attr_f08 +#define MPI_Win_get_info PMPI_Win_get_info +#define MPI_Win_get_info_f08 PMPI_Win_get_info_f08 +#define MPI_Win_get_name PMPI_Win_get_name +#define MPI_Win_get_name_f08 PMPI_Win_get_name_f08 +#define MPI_Win_set_attr PMPI_Win_set_attr +#define MPI_Win_set_attr_f08 PMPI_Win_set_attr_f08 +#define MPI_Win_set_info PMPI_Win_set_info +#define MPI_Win_set_info_f08 PMPI_Win_set_info_f08 +#define MPI_Win_set_name PMPI_Win_set_name +#define MPI_Win_set_name_f08 PMPI_Win_set_name_f08 +#define MPI_Cartdim_get PMPI_Cartdim_get +#define MPI_Cartdim_get_f08 PMPI_Cartdim_get_f08 +#define MPI_Cart_coords PMPI_Cart_coords +#define MPI_Cart_coords_f08 PMPI_Cart_coords_f08 +#define MPI_Cart_create PMPI_Cart_create +#define MPI_Cart_create_f08 PMPI_Cart_create_f08 +#define MPI_Cart_get PMPI_Cart_get +#define MPI_Cart_get_f08 PMPI_Cart_get_f08 +#define MPI_Cart_map PMPI_Cart_map +#define MPI_Cart_map_f08 PMPI_Cart_map_f08 +#define MPI_Cart_rank PMPI_Cart_rank +#define MPI_Cart_rank_f08 PMPI_Cart_rank_f08 +#define MPI_Cart_shift PMPI_Cart_shift +#define MPI_Cart_shift_f08 PMPI_Cart_shift_f08 +#define MPI_Cart_sub PMPI_Cart_sub +#define MPI_Cart_sub_f08 PMPI_Cart_sub_f08 +#define MPI_Dims_create PMPI_Dims_create +#define MPI_Dims_create_f08 PMPI_Dims_create_f08 +#define MPI_Dist_graph_create PMPI_Dist_graph_create +#define MPI_Dist_graph_create_f08 PMPI_Dist_graph_create_f08 +#define MPI_Dist_graph_create_adjacent PMPI_Dist_graph_create_adjacent +#define MPI_Dist_graph_create_adjacent_f08 PMPI_Dist_graph_create_adjacent_f08 +#define MPI_Dist_graph_neighbors PMPI_Dist_graph_neighbors +#define MPI_Dist_graph_neighbors_f08 PMPI_Dist_graph_neighbors_f08 +#define MPI_Dist_graph_neighbors_count PMPI_Dist_graph_neighbors_count +#define MPI_Dist_graph_neighbors_count_f08 PMPI_Dist_graph_neighbors_count_f08 +#define MPI_Graphdims_get PMPI_Graphdims_get +#define MPI_Graphdims_get_f08 PMPI_Graphdims_get_f08 +#define MPI_Graph_create PMPI_Graph_create +#define MPI_Graph_create_f08 PMPI_Graph_create_f08 +#define MPI_Graph_get PMPI_Graph_get +#define MPI_Graph_get_f08 PMPI_Graph_get_f08 +#define MPI_Graph_map PMPI_Graph_map +#define MPI_Graph_map_f08 PMPI_Graph_map_f08 +#define MPI_Graph_neighbors PMPI_Graph_neighbors +#define MPI_Graph_neighbors_f08 PMPI_Graph_neighbors_f08 +#define MPI_Graph_neighbors_count PMPI_Graph_neighbors_count +#define MPI_Graph_neighbors_count_f08 PMPI_Graph_neighbors_count_f08 +#define MPI_Topo_test PMPI_Topo_test +#define MPI_Topo_test_f08 PMPI_Topo_test_f08 +#define MPI_Aint_add PMPI_Aint_add +#define MPI_Aint_add_f08 PMPI_Aint_add_f08 +#define MPI_Aint_diff PMPI_Aint_diff +#define MPI_Aint_diff_f08 PMPI_Aint_diff_f08 +#define MPI_Abort PMPI_Abort +#define MPI_Abort_f08 PMPI_Abort_f08 +#define MPI_Add_error_class PMPI_Add_error_class +#define MPI_Add_error_class_f08 PMPI_Add_error_class_f08 +#define MPI_Add_error_code PMPI_Add_error_code +#define MPI_Add_error_code_f08 PMPI_Add_error_code_f08 +#define MPI_Add_error_string PMPI_Add_error_string +#define MPI_Add_error_string_f08 PMPI_Add_error_string_f08 +#define MPI_Alloc_mem PMPI_Alloc_mem +#define MPI_Alloc_mem_f08 PMPI_Alloc_mem_f08 +#define MPI_Comm_call_errhandler PMPI_Comm_call_errhandler +#define MPI_Comm_call_errhandler_f08 PMPI_Comm_call_errhandler_f08 +#define MPI_Comm_create_errhandler PMPI_Comm_create_errhandler +#define MPI_Comm_create_errhandler_f08 PMPI_Comm_create_errhandler_f08 +#define MPI_Comm_get_errhandler PMPI_Comm_get_errhandler +#define MPI_Comm_get_errhandler_f08 PMPI_Comm_get_errhandler_f08 +#define MPI_Comm_set_errhandler PMPI_Comm_set_errhandler +#define MPI_Comm_set_errhandler_f08 PMPI_Comm_set_errhandler_f08 +#define MPI_Errhandler_free PMPI_Errhandler_free +#define MPI_Errhandler_free_f08 PMPI_Errhandler_free_f08 +#define MPI_Error_class PMPI_Error_class +#define MPI_Error_class_f08 PMPI_Error_class_f08 +#define MPI_Error_string PMPI_Error_string +#define MPI_Error_string_f08 PMPI_Error_string_f08 +#define MPI_File_call_errhandler PMPI_File_call_errhandler +#define MPI_File_call_errhandler_f08 PMPI_File_call_errhandler_f08 +#define MPI_File_create_errhandler PMPI_File_create_errhandler +#define MPI_File_create_errhandler_f08 PMPI_File_create_errhandler_f08 +#define MPI_File_get_errhandler PMPI_File_get_errhandler +#define MPI_File_get_errhandler_f08 PMPI_File_get_errhandler_f08 +#define MPI_File_set_errhandler PMPI_File_set_errhandler +#define MPI_File_set_errhandler_f08 PMPI_File_set_errhandler_f08 +#define MPI_Finalize PMPI_Finalize +#define MPI_Finalize_f08 PMPI_Finalize_f08 +#define MPI_Finalized PMPI_Finalized +#define MPI_Finalized_f08 PMPI_Finalized_f08 +#define MPI_Free_mem PMPI_Free_mem +#define MPI_Free_mem_f08 PMPI_Free_mem_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Free_mem_f08ts PMPI_Free_mem_f08ts +#define MPI_Get_processor_name PMPI_Get_processor_name +#define MPI_Get_processor_name_f08 PMPI_Get_processor_name_f08 +#define MPI_Get_version PMPI_Get_version +#define MPI_Get_version_f08 PMPI_Get_version_f08 +#define MPI_Init PMPI_Init +#define MPI_Init_f08 PMPI_Init_f08 +#define MPI_Initialized PMPI_Initialized +#define MPI_Initialized_f08 PMPI_Initialized_f08 +#define MPI_Win_call_errhandler PMPI_Win_call_errhandler +#define MPI_Win_call_errhandler_f08 PMPI_Win_call_errhandler_f08 +#define MPI_Win_create_errhandler PMPI_Win_create_errhandler +#define MPI_Win_create_errhandler_f08 PMPI_Win_create_errhandler_f08 +#define MPI_Win_get_errhandler PMPI_Win_get_errhandler +#define MPI_Win_get_errhandler_f08 PMPI_Win_get_errhandler_f08 +#define MPI_Win_set_errhandler PMPI_Win_set_errhandler +#define MPI_Win_set_errhandler_f08 PMPI_Win_set_errhandler_f08 +#define MPI_Info_create PMPI_Info_create +#define MPI_Info_create_f08 PMPI_Info_create_f08 +#define MPI_Info_create_env PMPI_Info_create_env +#define MPI_Info_create_env_f08 PMPI_Info_create_env_f08 +#define MPI_Info_delete PMPI_Info_delete +#define MPI_Info_delete_f08 PMPI_Info_delete_f08 +#define MPI_Info_dup PMPI_Info_dup +#define MPI_Info_dup_f08 PMPI_Info_dup_f08 +#define MPI_Info_free PMPI_Info_free +#define MPI_Info_free_f08 PMPI_Info_free_f08 +#define MPI_Info_get PMPI_Info_get +#define MPI_Info_get_f08 PMPI_Info_get_f08 +#define MPI_Info_get_nkeys PMPI_Info_get_nkeys +#define MPI_Info_get_nkeys_f08 PMPI_Info_get_nkeys_f08 +#define MPI_Info_get_nthkey PMPI_Info_get_nthkey +#define MPI_Info_get_nthkey_f08 PMPI_Info_get_nthkey_f08 +#define MPI_Info_get_string PMPI_Info_get_string +#define MPI_Info_get_string_f08 PMPI_Info_get_string_f08 +#define MPI_Info_get_valuelen PMPI_Info_get_valuelen +#define MPI_Info_get_valuelen_f08 PMPI_Info_get_valuelen_f08 +#define MPI_Info_set PMPI_Info_set +#define MPI_Info_set_f08 PMPI_Info_set_f08 +#define MPI_Close_port PMPI_Close_port +#define MPI_Close_port_f08 PMPI_Close_port_f08 +#define MPI_Comm_accept PMPI_Comm_accept +#define MPI_Comm_accept_f08 PMPI_Comm_accept_f08 +#define MPI_Comm_connect PMPI_Comm_connect +#define MPI_Comm_connect_f08 PMPI_Comm_connect_f08 +#define MPI_Comm_disconnect PMPI_Comm_disconnect +#define MPI_Comm_disconnect_f08 PMPI_Comm_disconnect_f08 +#define MPI_Comm_get_parent PMPI_Comm_get_parent +#define MPI_Comm_get_parent_f08 PMPI_Comm_get_parent_f08 +#define MPI_Comm_join PMPI_Comm_join +#define MPI_Comm_join_f08 PMPI_Comm_join_f08 +#define MPI_Comm_spawn PMPI_Comm_spawn +#define MPI_Comm_spawn_f08 PMPI_Comm_spawn_f08 +#define MPI_Comm_spawn_multiple PMPI_Comm_spawn_multiple +#define MPI_Comm_spawn_multiple_f08 PMPI_Comm_spawn_multiple_f08 +#define MPI_Lookup_name PMPI_Lookup_name +#define MPI_Lookup_name_f08 PMPI_Lookup_name_f08 +#define MPI_Open_port PMPI_Open_port +#define MPI_Open_port_f08 PMPI_Open_port_f08 +#define MPI_Publish_name PMPI_Publish_name +#define MPI_Publish_name_f08 PMPI_Publish_name_f08 +#define MPI_Unpublish_name PMPI_Unpublish_name +#define MPI_Unpublish_name_f08 PMPI_Unpublish_name_f08 +#define MPI_Accumulate PMPI_Accumulate +#define MPI_Accumulate_f08 PMPI_Accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Accumulate_f08ts PMPI_Accumulate_f08ts +#define MPI_Raccumulate PMPI_Raccumulate +#define MPI_Raccumulate_f08 PMPI_Raccumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Raccumulate_f08ts PMPI_Raccumulate_f08ts +#define MPI_Get PMPI_Get +#define MPI_Get_f08 PMPI_Get_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_f08ts PMPI_Get_f08ts +#define MPI_Rget PMPI_Rget +#define MPI_Rget_f08 PMPI_Rget_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rget_f08ts PMPI_Rget_f08ts +#define MPI_Get_accumulate PMPI_Get_accumulate +#define MPI_Get_accumulate_f08 PMPI_Get_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_accumulate_f08ts PMPI_Get_accumulate_f08ts +#define MPI_Rget_accumulate PMPI_Rget_accumulate +#define MPI_Rget_accumulate_f08 PMPI_Rget_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rget_accumulate_f08ts PMPI_Rget_accumulate_f08ts +#define MPI_Put PMPI_Put +#define MPI_Put_f08 PMPI_Put_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Put_f08ts PMPI_Put_f08ts +#define MPI_Rput PMPI_Rput +#define MPI_Rput_f08 PMPI_Rput_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rput_f08ts PMPI_Rput_f08ts +#define MPI_Fetch_and_op PMPI_Fetch_and_op +#define MPI_Fetch_and_op_f08 PMPI_Fetch_and_op_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Fetch_and_op_f08ts PMPI_Fetch_and_op_f08ts +#define MPI_Compare_and_swap PMPI_Compare_and_swap +#define MPI_Compare_and_swap_f08 PMPI_Compare_and_swap_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Compare_and_swap_f08ts PMPI_Compare_and_swap_f08ts +#define MPI_Win_complete PMPI_Win_complete +#define MPI_Win_complete_f08 PMPI_Win_complete_f08 +#define MPI_Win_create PMPI_Win_create +#define MPI_Win_create_f08 PMPI_Win_create_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_create_f08ts PMPI_Win_create_f08ts +#define MPI_Win_create_dynamic PMPI_Win_create_dynamic +#define MPI_Win_create_dynamic_f08 PMPI_Win_create_dynamic_f08 +#define MPI_Win_attach PMPI_Win_attach +#define MPI_Win_attach_f08 PMPI_Win_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_attach_f08ts PMPI_Win_attach_f08ts +#define MPI_Win_detach PMPI_Win_detach +#define MPI_Win_detach_f08 PMPI_Win_detach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_detach_f08ts PMPI_Win_detach_f08ts +#define MPI_Win_fence PMPI_Win_fence +#define MPI_Win_fence_f08 PMPI_Win_fence_f08 +#define MPI_Win_free PMPI_Win_free +#define MPI_Win_free_f08 PMPI_Win_free_f08 +#define MPI_Win_get_group PMPI_Win_get_group +#define MPI_Win_get_group_f08 PMPI_Win_get_group_f08 +#define MPI_Win_lock PMPI_Win_lock +#define MPI_Win_lock_f08 PMPI_Win_lock_f08 +#define MPI_Win_lock_all PMPI_Win_lock_all +#define MPI_Win_lock_all_f08 PMPI_Win_lock_all_f08 +#define MPI_Win_post PMPI_Win_post +#define MPI_Win_post_f08 PMPI_Win_post_f08 +#define MPI_Win_shared_query PMPI_Win_shared_query +#define MPI_Win_shared_query_f08 PMPI_Win_shared_query_f08 +#define MPI_Win_start PMPI_Win_start +#define MPI_Win_start_f08 PMPI_Win_start_f08 +#define MPI_Win_sync PMPI_Win_sync +#define MPI_Win_sync_f08 PMPI_Win_sync_f08 +#define MPI_Win_test PMPI_Win_test +#define MPI_Win_test_f08 PMPI_Win_test_f08 +#define MPI_Win_unlock PMPI_Win_unlock +#define MPI_Win_unlock_f08 PMPI_Win_unlock_f08 +#define MPI_Win_unlock_all PMPI_Win_unlock_all +#define MPI_Win_unlock_all_f08 PMPI_Win_unlock_all_f08 +#define MPI_Win_wait PMPI_Win_wait +#define MPI_Win_wait_f08 PMPI_Win_wait_f08 +#define MPI_Win_flush PMPI_Win_flush +#define MPI_Win_flush_f08 PMPI_Win_flush_f08 +#define MPI_Win_flush_local PMPI_Win_flush_local +#define MPI_Win_flush_local_f08 PMPI_Win_flush_local_f08 +#define MPI_Win_flush_local_all PMPI_Win_flush_local_all +#define MPI_Win_flush_local_all_f08 PMPI_Win_flush_local_all_f08 +#define MPI_Win_flush_all PMPI_Win_flush_all +#define MPI_Win_flush_all_f08 PMPI_Win_flush_all_f08 +#define MPI_Grequest_complete PMPI_Grequest_complete +#define MPI_Grequest_complete_f08 PMPI_Grequest_complete_f08 +#define MPI_Grequest_start PMPI_Grequest_start +#define MPI_Grequest_start_f08 PMPI_Grequest_start_f08 +#define MPI_Init_thread PMPI_Init_thread +#define MPI_Init_thread_f08 PMPI_Init_thread_f08 +#define MPI_Is_thread_main PMPI_Is_thread_main +#define MPI_Is_thread_main_f08 PMPI_Is_thread_main_f08 +#define MPI_Query_thread PMPI_Query_thread +#define MPI_Query_thread_f08 PMPI_Query_thread_f08 +#define MPI_Status_f082f PMPI_Status_f082f +#define MPI_Status_f082f_f08 PMPI_Status_f082f_f08 +#define MPI_Status_f2f08 PMPI_Status_f2f08 +#define MPI_Status_f2f08_f08 PMPI_Status_f2f08_f08 +#define MPI_Status_set_cancelled PMPI_Status_set_cancelled +#define MPI_Status_set_cancelled_f08 PMPI_Status_set_cancelled_f08 +#define MPI_Status_set_elements PMPI_Status_set_elements +#define MPI_Status_set_elements_f08 PMPI_Status_set_elements_f08 +#define MPI_Status_set_elements_x PMPI_Status_set_elements_x +#define MPI_Status_set_elements_x_f08 PMPI_Status_set_elements_x_f08 +#define MPI_File_close PMPI_File_close +#define MPI_File_close_f08 PMPI_File_close_f08 +#define MPI_File_delete PMPI_File_delete +#define MPI_File_delete_f08 PMPI_File_delete_f08 +#define MPI_File_get_amode PMPI_File_get_amode +#define MPI_File_get_amode_f08 PMPI_File_get_amode_f08 +#define MPI_File_get_atomicity PMPI_File_get_atomicity +#define MPI_File_get_atomicity_f08 PMPI_File_get_atomicity_f08 +#define MPI_File_get_byte_offset PMPI_File_get_byte_offset +#define MPI_File_get_byte_offset_f08 PMPI_File_get_byte_offset_f08 +#define MPI_File_get_group PMPI_File_get_group +#define MPI_File_get_group_f08 PMPI_File_get_group_f08 +#define MPI_File_get_info PMPI_File_get_info +#define MPI_File_get_info_f08 PMPI_File_get_info_f08 +#define MPI_File_get_position PMPI_File_get_position +#define MPI_File_get_position_f08 PMPI_File_get_position_f08 +#define MPI_File_get_position_shared PMPI_File_get_position_shared +#define MPI_File_get_position_shared_f08 PMPI_File_get_position_shared_f08 +#define MPI_File_get_size PMPI_File_get_size +#define MPI_File_get_size_f08 PMPI_File_get_size_f08 +#define MPI_File_get_type_extent PMPI_File_get_type_extent +#define MPI_File_get_type_extent_f08 PMPI_File_get_type_extent_f08 +#define MPI_File_get_view PMPI_File_get_view +#define MPI_File_get_view_f08 PMPI_File_get_view_f08 +#define MPI_File_iread PMPI_File_iread +#define MPI_File_iread_f08 PMPI_File_iread_f08 +#define MPI_File_iread_at PMPI_File_iread_at +#define MPI_File_iread_at_f08 PMPI_File_iread_at_f08 +#define MPI_File_iread_all PMPI_File_iread_all +#define MPI_File_iread_all_f08 PMPI_File_iread_all_f08 +#define MPI_File_iread_at_all PMPI_File_iread_at_all +#define MPI_File_iread_at_all_f08 PMPI_File_iread_at_all_f08 +#define MPI_File_iread_shared PMPI_File_iread_shared +#define MPI_File_iread_shared_f08 PMPI_File_iread_shared_f08 +#define MPI_File_iwrite PMPI_File_iwrite +#define MPI_File_iwrite_f08 PMPI_File_iwrite_f08 +#define MPI_File_iwrite_at PMPI_File_iwrite_at +#define MPI_File_iwrite_at_f08 PMPI_File_iwrite_at_f08 +#define MPI_File_iwrite_all PMPI_File_iwrite_all +#define MPI_File_iwrite_all_f08 PMPI_File_iwrite_all_f08 +#define MPI_File_iwrite_at_all PMPI_File_iwrite_at_all +#define MPI_File_iwrite_at_all_f08 PMPI_File_iwrite_at_all_f08 +#define MPI_File_iwrite_shared PMPI_File_iwrite_shared +#define MPI_File_iwrite_shared_f08 PMPI_File_iwrite_shared_f08 +#define MPI_File_open PMPI_File_open +#define MPI_File_open_f08 PMPI_File_open_f08 +#define MPI_File_preallocate PMPI_File_preallocate +#define MPI_File_preallocate_f08 PMPI_File_preallocate_f08 +#define MPI_File_read PMPI_File_read +#define MPI_File_read_f08 PMPI_File_read_f08 +#define MPI_File_read_all PMPI_File_read_all +#define MPI_File_read_all_f08 PMPI_File_read_all_f08 +#define MPI_File_read_all_begin PMPI_File_read_all_begin +#define MPI_File_read_all_begin_f08 PMPI_File_read_all_begin_f08 +#define MPI_File_read_all_end PMPI_File_read_all_end +#define MPI_File_read_all_end_f08 PMPI_File_read_all_end_f08 +#define MPI_File_read_at PMPI_File_read_at +#define MPI_File_read_at_f08 PMPI_File_read_at_f08 +#define MPI_File_read_at_all PMPI_File_read_at_all +#define MPI_File_read_at_all_f08 PMPI_File_read_at_all_f08 +#define MPI_File_read_at_all_begin PMPI_File_read_at_all_begin +#define MPI_File_read_at_all_begin_f08 PMPI_File_read_at_all_begin_f08 +#define MPI_File_read_at_all_end PMPI_File_read_at_all_end +#define MPI_File_read_at_all_end_f08 PMPI_File_read_at_all_end_f08 +#define MPI_File_read_ordered PMPI_File_read_ordered +#define MPI_File_read_ordered_f08 PMPI_File_read_ordered_f08 +#define MPI_File_read_ordered_begin PMPI_File_read_ordered_begin +#define MPI_File_read_ordered_begin_f08 PMPI_File_read_ordered_begin_f08 +#define MPI_File_read_ordered_end PMPI_File_read_ordered_end +#define MPI_File_read_ordered_end_f08 PMPI_File_read_ordered_end_f08 +#define MPI_File_read_shared PMPI_File_read_shared +#define MPI_File_read_shared_f08 PMPI_File_read_shared_f08 +#define MPI_File_seek PMPI_File_seek +#define MPI_File_seek_f08 PMPI_File_seek_f08 +#define MPI_File_seek_shared PMPI_File_seek_shared +#define MPI_File_seek_shared_f08 PMPI_File_seek_shared_f08 +#define MPI_File_set_atomicity PMPI_File_set_atomicity +#define MPI_File_set_atomicity_f08 PMPI_File_set_atomicity_f08 +#define MPI_File_set_info PMPI_File_set_info +#define MPI_File_set_info_f08 PMPI_File_set_info_f08 +#define MPI_File_set_size PMPI_File_set_size +#define MPI_File_set_size_f08 PMPI_File_set_size_f08 +#define MPI_File_set_view PMPI_File_set_view +#define MPI_File_set_view_f08 PMPI_File_set_view_f08 +#define MPI_File_sync PMPI_File_sync +#define MPI_File_sync_f08 PMPI_File_sync_f08 +#define MPI_File_write PMPI_File_write +#define MPI_File_write_f08 PMPI_File_write_f08 +#define MPI_File_write_all PMPI_File_write_all +#define MPI_File_write_all_f08 PMPI_File_write_all_f08 +#define MPI_File_write_all_begin PMPI_File_write_all_begin +#define MPI_File_write_all_begin_f08 PMPI_File_write_all_begin_f08 +#define MPI_File_write_all_end PMPI_File_write_all_end +#define MPI_File_write_all_end_f08 PMPI_File_write_all_end_f08 +#define MPI_File_write_at PMPI_File_write_at +#define MPI_File_write_at_f08 PMPI_File_write_at_f08 +#define MPI_File_write_at_all PMPI_File_write_at_all +#define MPI_File_write_at_all_f08 PMPI_File_write_at_all_f08 +#define MPI_File_write_at_all_begin PMPI_File_write_at_all_begin +#define MPI_File_write_at_all_begin_f08 PMPI_File_write_at_all_begin_f08 +#define MPI_File_write_at_all_end PMPI_File_write_at_all_end +#define MPI_File_write_at_all_end_f08 PMPI_File_write_at_all_end_f08 +#define MPI_File_write_ordered PMPI_File_write_ordered +#define MPI_File_write_ordered_f08 PMPI_File_write_ordered_f08 +#define MPI_File_write_ordered_begin PMPI_File_write_ordered_begin +#define MPI_File_write_ordered_begin_f08 PMPI_File_write_ordered_begin_f08 +#define MPI_File_write_ordered_end PMPI_File_write_ordered_end +#define MPI_File_write_ordered_end_f08 PMPI_File_write_ordered_end_f08 +#define MPI_File_write_shared PMPI_File_write_shared +#define MPI_File_write_shared_f08 PMPI_File_write_shared_f08 +#define MPI_Register_datarep PMPI_Register_datarep +#define MPI_Register_datarep_f08 PMPI_Register_datarep_f08 +#define MPI_Type_create_f90_complex PMPI_Type_create_f90_complex +#define MPI_Type_create_f90_complex_f08 PMPI_Type_create_f90_complex_f08 +#define MPI_Type_create_f90_integer PMPI_Type_create_f90_integer +#define MPI_Type_create_f90_integer_f08 PMPI_Type_create_f90_integer_f08 +#define MPI_Type_create_f90_real PMPI_Type_create_f90_real +#define MPI_Type_create_f90_real_f08 PMPI_Type_create_f90_real_f08 +#define MPI_Type_match_size PMPI_Type_match_size +#define MPI_Type_match_size_f08 PMPI_Type_match_size_f08 +#define MPI_Pcontrol PMPI_Pcontrol +#define MPI_Pcontrol_f08 PMPI_Pcontrol_f08 +#define MPI_Comm_split_type PMPI_Comm_split_type +#define MPI_Comm_split_type_f08 PMPI_Comm_split_type_f08 +#define MPI_F_sync_reg PMPI_F_sync_reg +#define MPI_F_sync_reg_f08 PMPI_F_sync_reg_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_F_sync_reg_f08ts PMPI_F_sync_reg_f08ts +#define MPI_Get_library_version PMPI_Get_library_version +#define MPI_Get_library_version_f08 PMPI_Get_library_version_f08 +#define MPI_Mprobe PMPI_Mprobe +#define MPI_Mprobe_f08 PMPI_Mprobe_f08 +#define MPI_Improbe PMPI_Improbe +#define MPI_Improbe_f08 PMPI_Improbe_f08 +#define MPI_Imrecv PMPI_Imrecv +#define MPI_Imrecv_f08 PMPI_Imrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Imrecv_f08ts PMPI_Imrecv_f08ts +#define MPI_Mrecv PMPI_Mrecv +#define MPI_Mrecv_f08 PMPI_Mrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Mrecv_f08ts PMPI_Mrecv_f08ts +#define MPI_Neighbor_allgather PMPI_Neighbor_allgather +#define MPI_Neighbor_allgather_f08 PMPI_Neighbor_allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_allgather_f08ts PMPI_Neighbor_allgather_f08ts +#define MPI_Ineighbor_allgather PMPI_Ineighbor_allgather +#define MPI_Ineighbor_allgather_f08 PMPI_Ineighbor_allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_allgather_f08ts PMPI_Ineighbor_allgather_f08ts +#define MPI_Neighbor_allgather_init PMPI_Neighbor_allgather_init +#define MPI_Neighbor_allgather_init_f08 PMPI_Neighbor_allgather_init_f08 +#define MPI_Neighbor_allgatherv PMPI_Neighbor_allgatherv +#define MPI_Neighbor_allgatherv_f08 PMPI_Neighbor_allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_allgatherv_f08ts PMPI_Neighbor_allgatherv_f08ts +#define MPI_Ineighbor_allgatherv PMPI_Ineighbor_allgatherv +#define MPI_Ineighbor_allgatherv_f08 PMPI_Ineighbor_allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_allgatherv_f08ts PMPI_Ineighbor_allgatherv_f08ts +#define MPI_Neighbor_allgatherv_init PMPI_Neighbor_allgatherv_init +#define MPI_Neighbor_allgatherv_init_f08 PMPI_Neighbor_allgatherv_init_f08 +#define MPI_Neighbor_alltoall PMPI_Neighbor_alltoall +#define MPI_Neighbor_alltoall_f08 PMPI_Neighbor_alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoall_f08ts PMPI_Neighbor_alltoall_f08ts +#define MPI_Ineighbor_alltoall PMPI_Ineighbor_alltoall +#define MPI_Ineighbor_alltoall_f08 PMPI_Ineighbor_alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoall_f08ts PMPI_Ineighbor_alltoall_f08ts +#define MPI_Neighbor_alltoall_init PMPI_Neighbor_alltoall_init +#define MPI_Neighbor_alltoall_init_f08 PMPI_Neighbor_alltoall_init_f08 +#define MPI_Neighbor_alltoallv PMPI_Neighbor_alltoallv +#define MPI_Neighbor_alltoallv_f08 PMPI_Neighbor_alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoallv_f08ts PMPI_Neighbor_alltoallv_f08ts +#define MPI_Ineighbor_alltoallv PMPI_Ineighbor_alltoallv +#define MPI_Ineighbor_alltoallv_f08 PMPI_Ineighbor_alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoallv_f08ts PMPI_Ineighbor_alltoallv_f08ts +#define MPI_Neighbor_alltoallv_init PMPI_Neighbor_alltoallv_init +#define MPI_Neighbor_alltoallv_init_f08 PMPI_Neighbor_alltoallv_init_f08 +#define MPI_Neighbor_alltoallw PMPI_Neighbor_alltoallw +#define MPI_Neighbor_alltoallw_f08 PMPI_Neighbor_alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoallw_f08ts PMPI_Neighbor_alltoallw_f08ts +#define MPI_Ineighbor_alltoallw PMPI_Ineighbor_alltoallw +#define MPI_Ineighbor_alltoallw_f08 PMPI_Ineighbor_alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoallw_f08ts PMPI_Ineighbor_alltoallw_f08ts +#define MPI_Neighbor_alltoallw_init PMPI_Neighbor_alltoallw_init +#define MPI_Neighbor_alltoallw_init_f08 PMPI_Neighbor_alltoallw_init_f08 + +#elif @OMPI_FORTRAN_HAVE_TS@ + +#define MPI_Bsend_f08 MPI_Bsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Bsend_init_f08 MPI_Bsend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Buffer_attach_f08 MPI_Buffer_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ibsend_f08 MPI_Ibsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Irecv_f08 MPI_Irecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Irsend_f08 MPI_Irsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Isend_f08 MPI_Isend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Issend_f08 MPI_Issend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Recv_f08 MPI_Recv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Recv_init_f08 MPI_Recv_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rsend_f08 MPI_Rsend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rsend_init_f08 MPI_Rsend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Send_f08 MPI_Send_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Sendrecv_f08 MPI_Sendrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Sendrecv_replace_f08 MPI_Sendrecv_replace_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Send_init_f08 MPI_Send_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ssend_f08 MPI_Ssend_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ssend_init_f08 MPI_Ssend_init_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_address_f08 MPI_Get_address_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Pack_f08 MPI_Pack_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Pack_external_f08 MPI_Pack_external_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Unpack_f08 MPI_Unpack_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Unpack_external_f08 MPI_Unpack_external_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allgather_f08 MPI_Allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallgather_f08 MPI_Iallgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allgatherv_f08 MPI_Allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallgatherv_f08 MPI_Iallgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Allreduce_f08 MPI_Allreduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iallreduce_f08 MPI_Iallreduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoall_f08 MPI_Alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoall_f08 MPI_IaLltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoallv_f08 MPI_Alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoallv_f08 MPI_Ialltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Alltoallw_f08 MPI_Alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ialltoallw_f08 MPI_Ialltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Bcast_f08 MPI_Bcast_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ibcast_f08 MPI_Ibcast_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Exscan_f08 MPI_Exscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iexscan_f08 MPI_Iexscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Gather_f08 MPI_Gather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Igather_f08 MPI_Igather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Gatherv_f08 MPI_Gatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Igatherv_f08 MPI_Igatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_f08 MPI_Reduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_f08 MPI_Ireduce_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_local_f08 MPI_Reduce_local_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_scatter_f08 MPI_Reduce_scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_scatter_f08 MPI_Ireduce_scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Reduce_scatter_block_f08 MPI_Reduce_scatter_block_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ireduce_scatter_block_f08 MPI_Ireduce_scatter_block_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scan_f08 MPI_Scan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscan_f08 MPI_Iscan_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scatter_f08 MPI_Scatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscatter_f08 MPI_Iscatter_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Scatterv_f08 MPI_Scatterv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Iscatterv_f08 MPI_Iscatterv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Free_mem_f08 MPI_Free_mem_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Accumulate_f08 MPI_Accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Raccumulate_f08 MPI_Raccumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_f08 MPI_Get_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rget_f08 MPI_Rget_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Get_accumulate_f08 MPI_Get_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rget_accumulate_f08 MPI_Rget_accumulate_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Put_f08 MPI_Put_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Rput_f08 MPI_Rput_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Fetch_and_op_f08 MPI_Fetch_and_op_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Compare_and_swap_f08 MPI_Compare_and_swap_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_create_f08 MPI_Win_create_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_attach_f08 MPI_Win_attach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Win_detach_f08 MPI_Win_detach_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_F_sync_reg_f08 MPI_F_sync_reg_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Imrecv_f08 MPI_Imrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Mrecv_f08 MPI_Mrecv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_allgather_f08 MPI_Neighbor_allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_allgather_f08 MPI_Ineighbor_allgather_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_allgatherv_f08 MPI_Neighbor_allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_allgatherv_f08 MPI_Ineighbor_allgatherv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoall_f08 MPI_Neighbor_alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoall_f08 MPI_Ineighbor_alltoall_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoallv_f08 MPI_Neighbor_alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoallv_f08 MPI_Ineighbor_alltoallv_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Neighbor_alltoallw_f08 MPI_Neighbor_alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#define MPI_Ineighbor_alltoallw_f08 MPI_Ineighbor_alltoallw_f08@OMPI_F08_BINDINGS_TS_SUFFIX@ +#endif diff --git a/ompi/mpi/fortran/use-mpi-f08/put_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/put_f08.F90 index b58e4d88623..ebe01517632 100644 --- a/ompi/mpi/fortran/use-mpi-f08/put_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/put_f08.F90 @@ -16,7 +16,7 @@ subroutine MPI_Put_f08(origin_addr,origin_count,origin_datatype,target_rank,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_put_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/raccumulate_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/raccumulate_f08.F90 index 1935be341d4..f9b4f554954 100644 --- a/ompi/mpi/fortran/use-mpi-f08/raccumulate_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/raccumulate_f08.F90 @@ -17,7 +17,7 @@ subroutine MPI_Raccumulate_f08(origin_addr,origin_count,origin_datatype,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_Request, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_raccumulate_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/rget_accumulate_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/rget_accumulate_f08.F90 index f442abf2358..f134ed7c0fb 100644 --- a/ompi/mpi/fortran/use-mpi-f08/rget_accumulate_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/rget_accumulate_f08.F90 @@ -18,10 +18,10 @@ subroutine MPI_Rget_accumulate_f08(origin_addr,origin_count,origin_datatype,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Op, MPI_Win, MPI_Request, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_rget_accumulate_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, result_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: result_addr TYPE(MPI_Datatype), INTENT(IN) :: result_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp TYPE(MPI_Datatype), INTENT(IN) :: target_datatype diff --git a/ompi/mpi/fortran/use-mpi-f08/rget_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/rget_f08.F90 index 5e419fa8bfb..6ca4bc5f1ea 100644 --- a/ompi/mpi/fortran/use-mpi-f08/rget_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/rget_f08.F90 @@ -16,7 +16,7 @@ subroutine MPI_Rget_f08(origin_addr,origin_count,origin_datatype,target_rank,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_Request, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_rget_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/rput_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/rput_f08.F90 index efbca357754..7138b4d0334 100644 --- a/ompi/mpi/fortran/use-mpi-f08/rput_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/rput_f08.F90 @@ -16,7 +16,7 @@ subroutine MPI_Rput_f08(origin_addr,origin_count,origin_datatype,target_rank,& use :: mpi_f08_types, only : MPI_Datatype, MPI_Win, MPI_Request, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_rput_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr + OMPI_F08_IGNORE_TKR_TYPE, INTENT(IN) OMPI_ASYNCHRONOUS :: origin_addr INTEGER, INTENT(IN) :: origin_count, target_rank, target_count TYPE(MPI_Datatype), INTENT(IN) :: origin_datatype INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: target_disp diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/accumulate_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/accumulate_ts.c new file mode 100644 index 00000000000..a92d16019ec --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/accumulate_ts.c @@ -0,0 +1,64 @@ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Accumulate"; + +void ompi_accumulate_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *op, MPI_Fint *win, + MPI_Fint *ierr) +{ + int c_ierr; + + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + MPI_Op c_op = PMPI_Op_f2c(*op); + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Accumulate(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_op, c_win); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/compare_and_swap_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/compare_and_swap_ts.c new file mode 100644 index 00000000000..30689910b61 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/compare_and_swap_ts.c @@ -0,0 +1,67 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Compare_and_swap"; + +void ompi_compare_and_swap_ts(CFI_cdesc_t *x1, CFI_cdesc_t *x2, CFI_cdesc_t *x3, + MPI_Fint *datatype, MPI_Fint *target_rank, MPI_Aint *target_disp, + MPI_Fint *win, MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_datatype = PMPI_Type_f2c(*datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + char *origin_addr = x1->base_addr, *compare_addr = x2->base_addr, *result_addr = x3->base_addr; + + OMPI_CFI_CHECK_CONTIGUOUS(x1, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + OMPI_CFI_CHECK_CONTIGUOUS(x2, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + OMPI_CFI_CHECK_CONTIGUOUS(x3, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + return; + } + c_ierr = PMPI_Compare_and_swap(OMPI_F2C_BOTTOM(origin_addr), + OMPI_F2C_BOTTOM(compare_addr), + OMPI_F2C_BOTTOM(result_addr), + c_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, c_win); + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/fetch_and_op_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/fetch_and_op_ts.c new file mode 100644 index 00000000000..0d2a8c00367 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/fetch_and_op_ts.c @@ -0,0 +1,62 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Fetch_and_op"; + +void ompi_fetch_and_op_ts(CFI_cdesc_t *x1, CFI_cdesc_t *x2, MPI_Fint *datatype, + MPI_Fint *target_rank, MPI_Aint *target_disp, + MPI_Fint *op, MPI_Fint *win, MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_datatype = PMPI_Type_f2c(*datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + MPI_Op c_op = PMPI_Op_f2c(*op); + char *origin_addr = x1->base_addr, *result_addr = x2->base_addr; + + OMPI_CFI_CHECK_CONTIGUOUS(x1, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + OMPI_CFI_CHECK_CONTIGUOUS(x2, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Fetch_and_op(OMPI_F2C_BOTTOM(origin_addr), + OMPI_F2C_BOTTOM(result_addr), + c_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, c_op, c_win); + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/get_accumulate_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/get_accumulate_ts.c new file mode 100644 index 00000000000..bcf142d9191 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/get_accumulate_ts.c @@ -0,0 +1,84 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Get_accumulate"; + +void ompi_get_accumulate_ts(CFI_cdesc_t *x1, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, CFI_cdesc_t *x2, + MPI_Fint *result_count, MPI_Fint *result_datatype, + MPI_Fint *target_rank, MPI_Aint *target_disp, + MPI_Fint *target_count, MPI_Fint *target_datatype, + MPI_Fint *op, MPI_Fint *win, MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_result_datatype, c_result_type = PMPI_Type_f2c(*result_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + MPI_Op c_op = PMPI_Op_f2c(*op); + char *origin_addr = x1->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + char *result_addr = x2->base_addr; + int c_result_count = OMPI_INT_2_FINT(*result_count); + + OMPI_CFI_2_C(x1, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + OMPI_CFI_2_C(x2, c_result_count, c_result_type, c_result_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Get_accumulate(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_F2C_BOTTOM(result_addr), + c_result_count, + c_result_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_op, c_win); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (c_result_datatype != c_result_type) { + ompi_datatype_destroy(&c_result_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/get_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/get_ts.c new file mode 100644 index 00000000000..8456b249a78 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/get_ts.c @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Get"; + +void ompi_get_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *win, MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Get(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_win); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/put_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/put_ts.c new file mode 100644 index 00000000000..a5a237e7029 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/put_ts.c @@ -0,0 +1,60 @@ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Put"; + +void ompi_put_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *win, MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Put(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_win); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/raccumulate_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/raccumulate_ts.c new file mode 100644 index 00000000000..5159449c18e --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/raccumulate_ts.c @@ -0,0 +1,73 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014-2016 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Raccumulate"; + +void ompi_raccumulate_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *op, MPI_Fint *win, + MPI_Fint *request, MPI_Fint *ierr) +{ + int c_ierr; + + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + MPI_Op c_op = PMPI_Op_f2c(*op); + MPI_Request c_req; + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + c_ierr = PMPI_Raccumulate(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_op, c_win, + &c_req); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + + if (MPI_SUCCESS == c_ierr) { + *request = PMPI_Request_c2f(c_req); + } +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/rget_accumulate_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/rget_accumulate_ts.c new file mode 100644 index 00000000000..766d5a94072 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/rget_accumulate_ts.c @@ -0,0 +1,91 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014-2016 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * Copyright (c) 2015 FUJITSU LIMITED. All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Rget_accumulate"; + +void ompi_rget_accumulate_ts(CFI_cdesc_t *x1, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, CFI_cdesc_t *x2, + MPI_Fint *result_count, MPI_Fint *result_datatype, + MPI_Fint *target_rank, MPI_Aint *target_disp, + MPI_Fint *target_count, MPI_Fint *target_datatype, + MPI_Fint *op, MPI_Fint *win, MPI_Fint *request, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_result_datatype, c_result_type = PMPI_Type_f2c(*result_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + MPI_Op c_op = PMPI_Op_f2c(*op); + char *origin_addr = x1->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + char *result_addr = x2->base_addr; + int c_result_count = OMPI_INT_2_FINT(*result_count); + MPI_Request c_req; + + OMPI_CFI_2_C(x1, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME) + return; + } + OMPI_CFI_2_C(x2, c_result_count, c_result_type, c_result_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME); + return; + } + c_ierr = PMPI_Rget_accumulate(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_F2C_BOTTOM(result_addr), + c_result_count, + c_result_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_op, c_win, &c_req); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (c_result_datatype != c_result_type) { + ompi_datatype_destroy(&c_result_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + + if (MPI_SUCCESS == c_ierr) { + *request = PMPI_Request_c2f(c_req); + } +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/rget_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/rget_ts.c new file mode 100644 index 00000000000..ea48b2b2641 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/rget_ts.c @@ -0,0 +1,69 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014-2016 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Rget"; + +void ompi_rget_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *win, MPI_Fint *request, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + MPI_Request c_req; + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME); + return; + } + c_ierr = PMPI_Rget(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_win, &c_req); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + + if (MPI_SUCCESS == c_ierr) { + *request = PMPI_Request_c2f(c_req); + } +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/rput_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/rput_ts.c new file mode 100644 index 00000000000..bddc46f10f1 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/rput_ts.c @@ -0,0 +1,69 @@ +/* -*- Mode: C; c-basic-offset:4 ; indent-tabs-mode:nil -*- */ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2011-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2014-2016 Los Alamos National Security, LLC. All rights + * reserved. + * Copyright (c) 2015 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" +#include "ompi/mpi/fortran/base/constants.h" + +static const char FUNC_NAME[] = "MPI_Rput"; + +void ompi_rput_ts(CFI_cdesc_t *x, MPI_Fint *origin_count, + MPI_Fint *origin_datatype, MPI_Fint *target_rank, + MPI_Aint *target_disp, MPI_Fint *target_count, + MPI_Fint *target_datatype, MPI_Fint *win, MPI_Fint *request, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Datatype c_origin_datatype, c_origin_type = PMPI_Type_f2c(*origin_datatype); + MPI_Datatype c_target_datatype = PMPI_Type_f2c(*target_datatype); + MPI_Win c_win = PMPI_Win_f2c(*win); + char *origin_addr = x->base_addr; + int c_origin_count = OMPI_INT_2_FINT(*origin_count); + MPI_Request c_req; + + OMPI_CFI_2_C(x, c_origin_count, c_origin_type, c_origin_datatype, c_ierr); + if (MPI_SUCCESS != c_ierr) { + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME); + return; + } + c_ierr = PMPI_Rput(OMPI_F2C_BOTTOM(origin_addr), + c_origin_count, + c_origin_datatype, + OMPI_FINT_2_INT(*target_rank), + *target_disp, + OMPI_FINT_2_INT(*target_count), + c_target_datatype, c_win, &c_req); + if (c_origin_datatype != c_origin_type) { + ompi_datatype_destroy(&c_origin_datatype); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + + if (MPI_SUCCESS == c_ierr) { + *request = PMPI_Request_c2f(c_req); + } +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/win_attach_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/win_attach_ts.c new file mode 100644 index 00000000000..2917d7d41e7 --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/win_attach_ts.c @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" + +static const char FUNC_NAME[] = "MPI_Win_attach"; + +void ompi_win_attach_ts(MPI_Fint *win, CFI_cdesc_t *x, MPI_Aint *size, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Win c_win; + + c_win = PMPI_Win_f2c(*win); + if (OMPI_CFI_IS_CONTIGUOUS(x)) { + c_ierr = PMPI_Win_attach(c_win, x->base_addr, *size); + } else { + c_ierr = MPI_ERR_BUFFER; + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/win_create_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/win_create_ts.c new file mode 100644 index 00000000000..82afda3878e --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/win_create_ts.c @@ -0,0 +1,55 @@ +/* + * Copyright (c) 2004-2005 The Trustees of Indiana University and Indiana + * University Research and Technology + * Corporation. All rights reserved. + * Copyright (c) 2004-2005 The University of Tennessee and The University + * of Tennessee Research Foundation. All rights + * reserved. + * Copyright (c) 2004-2005 High Performance Computing Center Stuttgart, + * University of Stuttgart. All rights reserved. + * Copyright (c) 2004-2005 The Regents of the University of California. + * All rights reserved. + * Copyright (c) 2007-2012 Cisco Systems, Inc. All rights reserved. + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/communicator/communicator.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" + +static const char FUNC_NAME[] = "MPI_Win_create"; + +void ompi_win_create_ts(CFI_cdesc_t *x, MPI_Aint *size, MPI_Fint *disp_unit, + MPI_Fint *info, MPI_Fint *comm, MPI_Fint *win, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Win c_win; + MPI_Info c_info; + MPI_Comm c_comm; + + c_comm = PMPI_Comm_f2c(*comm); + c_info = PMPI_Info_f2c(*info); + + if (OMPI_CFI_IS_CONTIGUOUS(x)) { + c_ierr = PMPI_Win_create(x->base_addr, *size, + OMPI_FINT_2_INT(*disp_unit), + c_info, c_comm, &c_win); + } else { + c_ierr = MPI_ERR_BUFFER; + OMPI_ERRHANDLER_INVOKE(c_comm, c_ierr, FUNC_NAME); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); + + if (MPI_SUCCESS == c_ierr) { + *win = PMPI_Win_c2f(c_win); + } +} diff --git a/ompi/mpi/fortran/use-mpi-f08/ts/win_detach_ts.c b/ompi/mpi/fortran/use-mpi-f08/ts/win_detach_ts.c new file mode 100644 index 00000000000..f68a03d31db --- /dev/null +++ b/ompi/mpi/fortran/use-mpi-f08/ts/win_detach_ts.c @@ -0,0 +1,33 @@ +/* + * Copyright (c) 2015-2019 Research Organization for Information Science + * and Technology (RIST). All rights reserved. + * $COPYRIGHT$ + * + * Additional copyrights may follow + * + * $HEADER$ + */ + +#include "ompi_config.h" + +#include "ompi/win/win.h" +#include "ompi/errhandler/errhandler.h" +#include "ompi/mpi/fortran/use-mpi-f08/ts/bindings.h" + +static const char FUNC_NAME[] = "MPI_Win_detach"; + +void ompi_win_detach_ts(MPI_Fint *win, CFI_cdesc_t *x, + MPI_Fint *ierr) +{ + int c_ierr; + MPI_Win c_win; + + c_win = PMPI_Win_f2c(*win); + if (OMPI_CFI_IS_CONTIGUOUS(x)) { + c_ierr = PMPI_Win_detach(c_win, x->base_addr); + } else { + c_ierr = MPI_ERR_BUFFER; + OMPI_ERRHANDLER_INVOKE(c_win, c_ierr, FUNC_NAME); + } + if (NULL != ierr) *ierr = OMPI_INT_2_FINT(c_ierr); +} diff --git a/ompi/mpi/fortran/use-mpi-f08/win_attach_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/win_attach_f08.F90 index fb78b337158..fdb7ef930df 100644 --- a/ompi/mpi/fortran/use-mpi-f08/win_attach_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/win_attach_f08.F90 @@ -13,7 +13,7 @@ subroutine MPI_Win_attach_f08(win,base,size,ierror) use :: mpi_f08_types, only : MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_win_attach_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror diff --git a/ompi/mpi/fortran/use-mpi-f08/win_create_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/win_create_f08.F90 index 2376f399ce5..1699f52b4b4 100644 --- a/ompi/mpi/fortran/use-mpi-f08/win_create_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/win_create_f08.F90 @@ -16,7 +16,7 @@ subroutine MPI_Win_create_f08(base,size,disp_unit,info,comm,win,ierror) use :: mpi_f08_types, only : MPI_Info, MPI_Comm, MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_win_create_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS:: base + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS:: base INTEGER(MPI_ADDRESS_KIND), INTENT(IN) :: size INTEGER, INTENT(IN) :: disp_unit TYPE(MPI_Info), INTENT(IN) :: info diff --git a/ompi/mpi/fortran/use-mpi-f08/win_detach_f08.F90 b/ompi/mpi/fortran/use-mpi-f08/win_detach_f08.F90 index a85f5b62523..1865b2a7455 100644 --- a/ompi/mpi/fortran/use-mpi-f08/win_detach_f08.F90 +++ b/ompi/mpi/fortran/use-mpi-f08/win_detach_f08.F90 @@ -13,7 +13,7 @@ subroutine MPI_Win_detach_f08(win,base,ierror) use :: mpi_f08_types, only : MPI_Win, MPI_ADDRESS_KIND use :: ompi_mpifh_bindings, only : ompi_win_detach_f implicit none - OMPI_FORTRAN_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base + OMPI_F08_IGNORE_TKR_TYPE OMPI_ASYNCHRONOUS :: base TYPE(MPI_Win), INTENT(IN) :: win INTEGER, OPTIONAL, INTENT(OUT) :: ierror integer :: c_ierror