OpenACC: Update libgomp.texi + openacc{.f90,_lib.h} for 3.1 arg-name changes
Checks
| Context |
Check |
Description |
| linaro-tcwg-bot/tcwg_gcc_build--master-arm |
success
|
Testing passed
|
| linaro-tcwg-bot/tcwg_gcc_build--master-aarch64 |
success
|
Testing passed
|
| linaro-tcwg-bot/tcwg_gcc_check--master-aarch64 |
success
|
Testing passed
|
| linaro-tcwg-bot/tcwg_gcc_check--master-arm |
success
|
Testing passed
|
Commit Message
Side effect of having a look at the .texi file for OpenACC
for previous commit was that I spotted that the arguments
named did not match - and found a few smaller issues.
[In particular, OpenACC 3.1 did some larger argument renaming.]
The attached patch updates the manual to match OpenACC 3.3
specification for the implemented routines.
Besides the manual, it also updates the Fortran module/header file
as well and rather mechanically for the arg-name changes. Thanks
to compilation test with '-fimplicit-none' for both files (for *.h
as fixed and as free source form), the result should be fine.
(It also passed the testsuite, which is a useful but weaker test.)
Unfortunately, this spec change is a breaking change** for Fortran,
albeit only for users using the 'argname=' syntax when invoking
the routines. While that's only rarely done, I bet it will affect
one real-world program or another. However, the solution is just
to remove the "argname=" from the call.* - While usage can
be found in the libgomp testsuite, none is for the acc_ routines.
Comments, remarks, suggestions before I commit it?
Tobias
(* and to ensure the ordering hasn't be changed via the
argname= usage; besides documentation and reordering the main
use for the argname= is to leave out optional arguments while
specifying a later argument.)
** In the header file, I did see 'async_' a couple of times; those
weren't compatible argname= usage of OpenACC <= 3.0 neither ...
Comments
Hi Tobias!
On 2024-02-27T20:11:30+0100, Tobias Burnus <tburnus@baylibre.com> wrote:
> Side effect of having a look at the .texi file for OpenACC
> for previous commit was that I spotted that the arguments
> named did not match - and found a few smaller issues.
> [In particular, OpenACC 3.1 did some larger argument renaming.]
>
> The attached patch updates the manual to match OpenACC 3.3
> specification for the implemented routines.
But not update references to OpenACC 3.3, too?
> Besides the manual, it also updates the Fortran module/header file
> as well and rather mechanically for the arg-name changes. Thanks
> to compilation test with '-fimplicit-none' for both files (for *.h
> as fixed and as free source form), the result should be fine.
> (It also passed the testsuite, which is a useful but weaker test.)
>
> Unfortunately, this spec change is a breaking change** for Fortran,
> albeit only for users using the 'argname=' syntax when invoking
> the routines. While that's only rarely done, I bet it will affect
> one real-world program or another. However, the solution is just
> to remove the "argname=" from the call.* - While usage can
> be found in the libgomp testsuite, none is for the acc_ routines.
>
> Comments, remarks, suggestions before I commit it?
The questions is whether we want to do this now, or once we actually
support 3.1 or 3.3; what was your intention for preparing this now?
> (* and to ensure the ordering hasn't be changed via the
> argname= usage; besides documentation and reordering the main
> use for the argname= is to leave out optional arguments while
> specifying a later argument.)
>
> ** In the header file, I did see 'async_' a couple of times; those
> weren't compatible argname= usage of OpenACC <= 3.0 neither ...
> OpenACC: Update libgomp.texi + openacc{.f90,_lib.h} for 3.1 arg-name changes
>
> This commit handles the following OpenACC 3.1 changes:
>
> First, several argument names were renamed: len -> bytes, a -> data_arg,
> async -> async_arg, arg -> wait_arg, devicenum -> dev_num,
> and devicetype -> dev_type.
>
> Secondly, it also changed the slightly odd 'type, dimension(:[,:]...)'
> to 'type(*), dimension(..)'.
>
> The commit also fixes some minor issues as encountered (wrong function
> name in Fortran part of 'acc_async_test_all', bogus 'void' for Fortran,
> missing 'void' for C).
>
> Those argument changes had to be also put into the Fortran files, which
> this commit does.
>
> NOTE: Those argument names *do* have an effect and can be a breaking
> change as Fortran permits using the arg name in the call, e.g.,
> call acc_copyin(a=myVar) ! old
> must now be called either as
> call acc_copyin(data_arg=myVar) ! new
> or as
> call acc_copyin(myVar) ! works with old and new names
> As the latter is way more common, the spec change hopefully does not
> break too many programs.
I wonder: would it happen to be possible via "Fortran interface magic" to
actually support several variants of named arguments? I agree we can
drop any bogus GCC-local variants, but is it possible to support all the
official variants?
> And, finally, it synced over all named constants from openacc.f90 to
> config/accel/openacc.f90.
I don't think that's necessary: as I understand, that one's for
'acc_on_device' only?
Grüße
Thomas
> libgomp/ChangeLog:
>
> * libgomp.texi (OpenACC Runtime Library Routines): Minor fixes
> and update to 3.1 routine argument names.
> * openacc_lib.h: Update routine argument names.
> * openacc.f90: Likewise.
> * config/accel/openacc.f90: Likewise; add all named constants
> that have been accumulated so far.
>
> libgomp/config/accel/openacc.f90 | 42 +-
> libgomp/libgomp.texi | 504 ++++++++--------
> libgomp/openacc.f90 | 1200 +++++++++++++++++++-------------------
> libgomp/openacc_lib.h | 438 +++++++-------
> 4 files changed, 1108 insertions(+), 1076 deletions(-)
>
> diff --git a/libgomp/config/accel/openacc.f90 b/libgomp/config/accel/openacc.f90
> index 63eaedc02c2..c7526311899 100644
> --- a/libgomp/config/accel/openacc.f90
> +++ b/libgomp/config/accel/openacc.f90
> @@ -53,6 +53,23 @@ module openacc_kinds
> integer (acc_device_kind), parameter :: acc_device_nvidia = 5
> integer (acc_device_kind), parameter :: acc_device_radeon = 8
>
> + integer, parameter :: acc_device_property_kind = int32
> + ! OpenACC 2.6/2.7/3.0 used acc_device_property; in a spec update the
> + ! missing '_kind' was added for consistency. For backward compatibility, keep:
> + integer, parameter :: acc_device_property = acc_device_property_kind
> +
> + ! Keep in sync with 'libgomp/libgomp-plugin.h:goacc_property'.
> + integer (acc_device_property_kind), parameter :: acc_property_memory = 1
> + integer (acc_device_property_kind), parameter :: acc_property_free_memory = 2
> + integer (acc_device_property_kind), parameter :: acc_property_name = int(Z'10001')
> + integer (acc_device_property_kind), parameter :: acc_property_vendor = int(Z'10002')
> + integer (acc_device_property_kind), parameter :: acc_property_driver = int(Z'10003')
> +
> + integer, parameter :: acc_handle_kind = int32
> +
> + ! Keep in sync with include/gomp-constants.h.
> + integer (acc_handle_kind), parameter :: acc_async_noval = -1
> + integer (acc_handle_kind), parameter :: acc_async_sync = -2
> end module openacc_kinds
>
> module openacc_internal
> @@ -60,19 +77,19 @@ module openacc_internal
> implicit none
>
> interface
> - function acc_on_device_h (devicetype)
> + function acc_on_device_h (dev_type)
> import
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> logical acc_on_device_h
> end function
> end interface
>
> interface
> - function acc_on_device_l (devicetype) &
> + function acc_on_device_l (dev_type) &
> bind (C, name = "acc_on_device")
> use iso_c_binding, only: c_int
> integer (c_int) :: acc_on_device_l
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end function
> end interface
> end module openacc_internal
> @@ -89,18 +106,29 @@ module openacc
> public :: acc_device_none, acc_device_default, acc_device_host
> public :: acc_device_not_host, acc_device_nvidia, acc_device_radeon
>
> + public :: acc_device_property_kind, acc_device_property
> + public :: acc_property_memory, acc_property_free_memory
> + public :: acc_property_name, acc_property_vendor, acc_property_driver
> +
> + public :: acc_handle_kind
> + public :: acc_async_noval, acc_async_sync
> +
> + public :: openacc_version
> +
> public :: acc_on_device
>
> + integer, parameter :: openacc_version = 201711
> +
> interface acc_on_device
> procedure :: acc_on_device_h
> end interface
>
> end module openacc
>
> -function acc_on_device_h (devicetype)
> +function acc_on_device_h (dev_type)
> use openacc_internal, only: acc_on_device_l
> use openacc_kinds
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> logical acc_on_device_h
> - acc_on_device_h = acc_on_device_l (devicetype) /= 0
> + acc_on_device_h = acc_on_device_l (dev_type) /= 0
> end function
> diff --git a/libgomp/libgomp.texi b/libgomp/libgomp.texi
> index bf5c7a76fc9..226078e4cf1 100644
> --- a/libgomp/libgomp.texi
> +++ b/libgomp/libgomp.texi
> @@ -4271,17 +4271,17 @@ API routines for the OpenACC Profiling Interface.
> @table @asis
> @item @emph{Description}
> This function returns a value indicating the number of devices available
> -for the device type specified in @var{devicetype}.
> +for the device type specified in @var{dev_type}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(devicetype)}
> -@item @tab @code{integer(kind=acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4296,17 +4296,17 @@ for the device type specified in @var{devicetype}.
> @table @asis
> @item @emph{Description}
> This function indicates to the runtime library which device type, specified
> -in @var{devicetype}, to use when executing a parallel or kernels region.
> +in @var{dev_type}, to use when executing a parallel or kernels region.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_set_device_type(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{void acc_set_device_type(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(devicetype)}
> -@item @tab @code{integer(kind=acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4336,8 +4336,8 @@ Interface}), that is, if the device is currently being initialized.
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_get_device_type(void)}
> -@item @tab @code{integer(kind=acc_device_kind) acc_get_device_type}
> +@item @emph{Interface}: @tab @code{function acc_get_device_type()}
> +@item @tab @code{integer(acc_device_kind) acc_get_device_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4352,19 +4352,19 @@ Interface}), that is, if the device is currently being initialized.
> @table @asis
> @item @emph{Description}
> This function will indicate to the runtime which device number,
> -specified by @var{devicenum}, associated with the specified device
> -type @var{devicetype}.
> +specified by @var{dev_num}, associated with the specified device
> +type @var{dev_type}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_set_device_num(int devicenum, acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{void acc_set_device_num(int dev_num, acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(devicenum, devicetype)}
> -@item @tab @code{integer devicenum}
> -@item @tab @code{integer(kind=acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(dev_num, dev_type)}
> +@item @tab @code{integer dev_num}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4379,18 +4379,18 @@ type @var{devicetype}.
> @table @asis
> @item @emph{Description}
> This function returns which device number associated with the specified device
> -type @var{devicetype}, will be used when executing a parallel or kernels
> +type @var{dev_type}, will be used when executing a parallel or kernels
> region.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_get_device_num(devicetype)}
> -@item @tab @code{integer(kind=acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{function acc_get_device_num(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @item @tab @code{integer acc_get_device_num}
> @end multitable
>
> @@ -4408,7 +4408,7 @@ region.
> @table @asis
> @item @emph{Description}
> These routines return the value of the specified @var{property} for the
> -device being queried according to @var{devicenum} and @var{devicetype}.
> +device being queried according to @var{dev_num} and @var{dev_type}.
> Integer-valued and string-valued properties are returned by
> @code{acc_get_property} and @code{acc_get_property_string} respectively.
> The Fortran @code{acc_get_property_string} subroutine returns the string
> @@ -4425,19 +4425,19 @@ but might be removed in a future version of GCC.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{size_t acc_get_property(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
> -@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
> +@item @emph{Prototype}: @tab @code{size_t acc_get_property(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
> +@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_get_property(devicenum, devicetype, property)}
> -@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(devicenum, devicetype, property, string)}
> +@item @emph{Interface}: @tab @code{function acc_get_property(dev_num, dev_type, property)}
> +@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(dev_num, dev_type, property, string)}
> @item @tab @code{use ISO_C_Binding, only: c_size_t}
> -@item @tab @code{integer devicenum}
> -@item @tab @code{integer(kind=acc_device_kind) devicetype}
> -@item @tab @code{integer(kind=acc_device_property_kind) property}
> -@item @tab @code{integer(kind=c_size_t) acc_get_property}
> +@item @tab @code{integer dev_num}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> +@item @tab @code{integer(acc_device_property_kind) property}
> +@item @tab @code{integer(c_size_t) acc_get_property}
> @item @tab @code{character(*) string}
> @end multitable
>
> @@ -4453,20 +4453,20 @@ but might be removed in a future version of GCC.
> @table @asis
> @item @emph{Description}
> This function tests for completion of the asynchronous operation specified
> -in @var{arg}. In C/C++, a non-zero value is returned to indicate
> +in @var{wait_arg}. In C/C++, a non-zero value is returned to indicate
> the specified asynchronous operation has completed while Fortran returns
> @code{true}. If the asynchronous operation has not completed, C/C++ returns
> zero and Fortran returns @code{false}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{int acc_async_test(int arg);}
> +@item @emph{Prototype}: @tab @code{int acc_async_test(int wait_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_async_test(arg)}
> -@item @tab @code{integer(kind=acc_handle_kind) arg}
> +@item @emph{Interface}: @tab @code{function acc_async_test(wait_arg)}
> +@item @tab @code{integer(acc_handle_kind) wait_arg}
> @item @tab @code{logical acc_async_test}
> @end multitable
>
> @@ -4494,8 +4494,8 @@ Fortran returns @code{false}.
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_async_test()}
> -@item @tab @code{logical acc_get_device_num}
> +@item @emph{Interface}: @tab @code{function acc_async_test_all()}
> +@item @tab @code{logical acc_async_test_all}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4510,20 +4510,20 @@ Fortran returns @code{false}.
> @table @asis
> @item @emph{Description}
> This function waits for completion of the asynchronous operation
> -specified in @var{arg}.
> +specified in @var{wait_arg}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_wait(arg);}
> -@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait(arg);}
> +@item @emph{Prototype}: @tab @code{void acc_wait(wait_arg);}
> +@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait(wait_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_wait(arg)}
> -@item @tab @code{integer(acc_handle_kind) arg}
> -@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(arg)}
> -@item @tab @code{integer(acc_handle_kind) arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_wait(wait_arg)}
> +@item @tab @code{integer(acc_handle_kind) wait_arg}
> +@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(wait_arg)}
> +@item @tab @code{integer(acc_handle_kind) wait_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4541,8 +4541,8 @@ This function waits for the completion of all asynchronous operations.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_wait_all(void);}
> -@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait_all(void);}
> +@item @emph{Prototype}: @tab @code{void acc_wait_all(void);}
> +@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait_all(void);}
> @end multitable
>
> @item @emph{Fortran}:
> @@ -4562,19 +4562,19 @@ This function waits for the completion of all asynchronous operations.
> @section @code{acc_wait_all_async} -- Wait for completion of all asynchronous operations.
> @table @asis
> @item @emph{Description}
> -This function enqueues a wait operation on the queue @var{async} for any
> +This function enqueues a wait operation on the queue @var{async_arg} for any
> and all asynchronous operations that have been previously enqueued on
> any queue.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_wait_all_async(int async);}
> +@item @emph{Prototype}: @tab @code{void acc_wait_all_async(int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async)}
> -@item @tab @code{integer(acc_handle_kind) async}
> +@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async_arg)}
> +@item @tab @code{integer(acc_handle_kind) async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4588,18 +4588,18 @@ any queue.
> @section @code{acc_wait_async} -- Wait for completion of asynchronous operations.
> @table @asis
> @item @emph{Description}
> -This function enqueues a wait operation on queue @var{async} for any and all
> -asynchronous operations enqueued on queue @var{arg}.
> +This function enqueues a wait operation on queue @var{async_arg} for any and all
> +asynchronous operations enqueued on queue @var{wait_arg}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_wait_async(int arg, int async);}
> +@item @emph{Prototype}: @tab @code{void acc_wait_async(int wait_arg, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_wait_async(arg, async)}
> -@item @tab @code{integer(acc_handle_kind) arg, async}
> +@item @emph{Interface}: @tab @code{subroutine acc_wait_async(wait_arg, async_arg)}
> +@item @tab @code{integer(acc_handle_kind) wait_arg, async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4614,17 +4614,17 @@ asynchronous operations enqueued on queue @var{arg}.
> @table @asis
> @item @emph{Description}
> This function initializes the runtime for the device type specified in
> -@var{devicetype}.
> +@var{dev_type}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_init(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{void acc_init(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_init(devicetype)}
> -@item @tab @code{integer(acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{subroutine acc_init(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4639,17 +4639,17 @@ This function initializes the runtime for the device type specified in
> @table @asis
> @item @emph{Description}
> This function shuts down the runtime for the device type specified in
> -@var{devicetype}.
> +@var{dev_type}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_shutdown(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{void acc_shutdown(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_shutdown(devicetype)}
> -@item @tab @code{integer(acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{subroutine acc_shutdown(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4664,7 +4664,7 @@ This function shuts down the runtime for the device type specified in
> @table @asis
> @item @emph{Description}:
> This function returns whether the program is executing on a particular
> -device specified in @var{devicetype}. In C/C++ a non-zero value is
> +device specified in @var{dev_type}. In C/C++ a non-zero value is
> returned to indicate the device is executing on the specified device type.
> In Fortran, @code{true} is returned. If the program is not executing
> on the specified device type C/C++ returns zero, while Fortran
> @@ -4672,13 +4672,13 @@ returns @code{false}.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_on_device(acc_device_t devicetype);}
> +@item @emph{Prototype}: @tab @code{void acc_on_device(acc_device_t dev_type);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_on_device(devicetype)}
> -@item @tab @code{integer(acc_device_kind) devicetype}
> +@item @emph{Interface}: @tab @code{function acc_on_device(dev_type)}
> +@item @tab @code{integer(acc_device_kind) dev_type}
> @item @tab @code{logical acc_on_device}
> @end multitable
>
> @@ -4744,34 +4744,34 @@ Free previously allocated device memory at the device address @code{data_dev}.
> @section @code{acc_copyin} -- Allocate device memory and copy host memory to it.
> @table @asis
> @item @emph{Description}
> -In C/C++, this function allocates @var{len} bytes of device memory
> -and maps it to the specified host address in @var{a}. The device
> +In C/C++, this function allocates @var{bytes} bytes of device memory
> +and maps it to the specified host address in @var{data_arg}. The device
> address of the newly allocated device memory is returned.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a
> -variable or array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a
> +variable or array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *a, size_t len, int async);}
> +@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *data_arg, size_t bytes, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_copyin(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyin(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4785,36 +4785,36 @@ variable or array element and @var{len} specifies the length in bytes.
> @section @code{acc_present_or_copyin} -- If the data is not present on the device, allocate device memory and copy from host memory.
> @table @asis
> @item @emph{Description}
> -This function tests if the host data specified by @var{a} and of length
> -@var{len} is present or not. If it is not present, device memory
> +This function tests if the host data specified by @var{data_arg} and of length
> +@var{bytes} is present or not. If it is not present, device memory
> is allocated and the host memory copied. The device address of
> the newly allocated device memory is returned.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> Note that @code{acc_present_or_copyin} and @code{acc_pcopyin} exist for
> backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *a, size_t len);}
> +@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *data_arg, size_t bytes);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> +@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4829,33 +4829,33 @@ backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
> @table @asis
> @item @emph{Description}
> This function allocates device memory and maps it to host memory specified
> -by the host address @var{a} with a length of @var{len} bytes. In C/C++,
> +by the host address @var{data_arg} with a length of @var{bytes} bytes. In C/C++,
> the function returns the device address of the allocated device memory.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{void *acc_create(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *a, size_t len, int async);}
> +@item @emph{Prototype}: @tab @code{void *acc_create(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *data_arg, size_t bytes, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_create(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_create(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4869,36 +4869,36 @@ array element and @var{len} specifies the length in bytes.
> @section @code{acc_present_or_create} -- If the data is not present on the device, allocate device memory and map it to host memory.
> @table @asis
> @item @emph{Description}
> -This function tests if the host data specified by @var{a} and of length
> -@var{len} is present or not. If it is not present, device memory
> +This function tests if the host data specified by @var{data_args} and of length
> +@var{bytes} is present or not. If it is not present, device memory
> is allocated and mapped to host memory. In C/C++, the device address
> of the newly allocated device memory is returned.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_args} specifies
> +a contiguous array section. The second form @var{data_args} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> Note that @code{acc_present_or_create} and @code{acc_pcreate} exist for
> backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *a, size_t len)}
> -@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *a, size_t len)}
> +@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *data_args, size_t bytes)}
> +@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *data_args, size_t bytes)}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> +@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args)}
> +@item @tab @code{type(*), dimension(..) :: data_args}
> +@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_args}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args)}
> +@item @tab @code{type(*), dimension(..) :: data_args}
> +@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_args}
> +@item @tab @code{integer bytes}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4913,46 +4913,46 @@ backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
> @table @asis
> @item @emph{Description}
> This function copies mapped device memory to host memory which is specified
> -by host address @var{a} for a length @var{len} bytes in C/C++.
> +by host address @var{data_arg} for a length @var{bytes} bytes in C/C++.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_copyout(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_copyout_async(h_void *a, size_t len, int async);}
> -@item @emph{Prototype}: @tab @code{acc_copyout_finalize(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_copyout_finalize_async(h_void *a, size_t len, int async);}
> +@item @emph{Prototype}: @tab @code{void acc_copyout(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void acc_copyout_async(h_void *data_arg, size_t bytes, int async_arg);}
> +@item @emph{Prototype}: @tab @code{void acc_copyout_finalize(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void acc_copyout_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -4967,46 +4967,46 @@ array element and @var{len} specifies the length in bytes.
> @table @asis
> @item @emph{Description}
> This function frees previously allocated device memory specified by
> -the device address @var{a} and the length of @var{len} bytes.
> +the device address @var{data_arg} and the length of @var{bytes} bytes.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_delete(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *a, size_t len, int async);}
> -@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *a, size_t len, int async);}
> +@item @emph{Prototype}: @tab @code{acc_delete(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *data_arg, size_t bytes, int async_arg);}
> +@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_delete(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -5021,33 +5021,33 @@ array element and @var{len} specifies the length in bytes.
> @table @asis
> @item @emph{Description}
> This function updates the device copy from the previously mapped host memory.
> -The host memory is specified with the host address @var{a} and a length of
> -@var{len} bytes.
> +The host memory is specified with the host address @var{data_arg} and a length of
> +@var{bytes} bytes.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len, async);}
> +@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes, async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_update_device(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_device(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -5062,33 +5062,33 @@ array element and @var{len} specifies the length in bytes.
> @table @asis
> @item @emph{Description}
> This function updates the host copy from the previously mapped device memory.
> -The host memory is specified with the host address @var{a} and a length of
> -@var{len} bytes.
> +The host memory is specified with the host address @var{data_arg} and a length of
> +@var{bytes} bytes.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes.
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{acc_update_self(h_void *a, size_t len);}
> -@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *a, size_t len, int async);}
> +@item @emph{Prototype}: @tab @code{acc_update_self(h_void *data_arg, size_t bytes);}
> +@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *data_arg, size_t bytes, int async_arg);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{subroutine acc_update_self(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_self(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> -@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, len, async)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> -@item @tab @code{integer(acc_handle_kind) :: async}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> +@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, bytes, async_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> +@item @tab @code{integer(acc_handle_kind) :: async_arg}
> @end multitable
>
> @item @emph{Reference}:
> @@ -5209,31 +5209,31 @@ device address specified by @var{data_dev}.
> @section @code{acc_is_present} -- Indicate whether host variable / array is present on device.
> @table @asis
> @item @emph{Description}
> -This function indicates whether the specified host address in @var{a} and a
> -length of @var{len} bytes is present on the device. In C/C++, a non-zero
> +This function indicates whether the specified host address in @var{data_arg} and a
> +length of @var{bytes} bytes is present on the device. In C/C++, a non-zero
> value is returned to indicate the presence of the mapped memory on the
> device. A zero is returned to indicate the memory is not mapped on the
> device.
>
> -In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
> -a contiguous array section. The second form @var{a} specifies a variable or
> -array element and @var{len} specifies the length in bytes. If the host
> +In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
> +a contiguous array section. The second form @var{data_arg} specifies a variable or
> +array element and @var{bytes} specifies the length in bytes. If the host
> memory is mapped to device memory, then a @code{true} is returned. Otherwise,
> a @code{false} is return to indicate the mapped memory is not present.
>
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> -@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *a, size_t len);}
> +@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *data_arg, size_t bytes);}
> @end multitable
>
> @item @emph{Fortran}:
> @multitable @columnfractions .20 .80
> -@item @emph{Interface}: @tab @code{function acc_is_present(a)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> +@item @emph{Interface}: @tab @code{function acc_is_present(data_arg)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> @item @tab @code{logical acc_is_present}
> -@item @emph{Interface}: @tab @code{function acc_is_present(a, len)}
> -@item @tab @code{type, dimension(:[,:]...) :: a}
> -@item @tab @code{integer len}
> +@item @emph{Interface}: @tab @code{function acc_is_present(data_arg, bytes)}
> +@item @tab @code{type(*), dimension(..) :: data_arg}
> +@item @tab @code{integer bytes}
> @item @tab @code{logical acc_is_present}
> @end multitable
>
> @@ -5326,7 +5326,7 @@ address to pointing to the corresponding device data.
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> @item @emph{Prototype}: @tab @code{void acc_attach(h_void **ptr_addr);}
> -@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async);}
> +@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async_arg);}
> @end multitable
>
> @c @item @emph{Fortran}:
> @@ -5356,9 +5356,9 @@ address to pointing to the corresponding host data.
> @item @emph{C/C++}:
> @multitable @columnfractions .20 .80
> @item @emph{Prototype}: @tab @code{void acc_detach(h_void **ptr_addr);}
> -@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async);}
> +@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async_arg);}
> @item @emph{Prototype}: @tab @code{void acc_detach_finalize(h_void **ptr_addr);}
> -@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async);}
> +@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async_arg);}
> @end multitable
>
> @c @item @emph{Fortran}:
> diff --git a/libgomp/openacc.f90 b/libgomp/openacc.f90
> index 4e24ee46a97..c5c99b5fa9d 100644
> --- a/libgomp/openacc.f90
> +++ b/libgomp/openacc.f90
> @@ -74,15 +74,15 @@ module openacc_internal
> implicit none
>
> interface
> - function acc_get_num_devices_h (devicetype)
> + function acc_get_num_devices_h (dev_type)
> import
> integer acc_get_num_devices_h
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end function
>
> - subroutine acc_set_device_type_h (devicetype)
> + subroutine acc_set_device_type_h (dev_type)
> import
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
>
> function acc_get_device_type_h ()
> @@ -90,435 +90,435 @@ module openacc_internal
> integer (acc_device_kind) acc_get_device_type_h
> end function
>
> - subroutine acc_set_device_num_h (devicenum, devicetype)
> + subroutine acc_set_device_num_h (dev_num, dev_type)
> import
> - integer devicenum
> - integer (acc_device_kind) devicetype
> + integer dev_num
> + integer (acc_device_kind) dev_type
> end subroutine
>
> - function acc_get_device_num_h (devicetype)
> + function acc_get_device_num_h (dev_type)
> import
> integer acc_get_device_num_h
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end function
>
> - function acc_get_property_h (devicenum, devicetype, property)
> + function acc_get_property_h (dev_num, dev_type, property)
> use iso_c_binding, only: c_size_t
> import
> implicit none (type, external)
> integer (c_size_t) :: acc_get_property_h
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> end function
>
> - subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
> + subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
> import
> implicit none (type, external)
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> character (*) :: string
> end subroutine
>
> - function acc_async_test_h (arg)
> + function acc_async_test_h (wait_arg)
> logical acc_async_test_h
> - integer arg
> + integer wait_arg
> end function
>
> function acc_async_test_all_h ()
> logical acc_async_test_all_h
> end function
>
> - subroutine acc_wait_h (arg)
> - integer arg
> + subroutine acc_wait_h (wait_arg)
> + integer wait_arg
> end subroutine
>
> - subroutine acc_wait_async_h (arg, async)
> - integer arg, async
> + subroutine acc_wait_async_h (wait_arg, async_arg)
> + integer wait_arg, async_arg
> end subroutine
>
> subroutine acc_wait_all_h ()
> end subroutine
>
> - subroutine acc_wait_all_async_h (async)
> - integer async
> + subroutine acc_wait_all_async_h (async_arg)
> + integer async_arg
> end subroutine
>
> - subroutine acc_init_h (devicetype)
> + subroutine acc_init_h (dev_type)
> import
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
>
> - subroutine acc_shutdown_h (devicetype)
> + subroutine acc_shutdown_h (dev_type)
> import
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
>
> - function acc_on_device_h (devicetype)
> + function acc_on_device_h (dev_type)
> import
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> logical acc_on_device_h
> end function
>
> - subroutine acc_copyin_32_h (a, len)
> + subroutine acc_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyin_64_h (a, len)
> + subroutine acc_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyin_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyin_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_present_or_copyin_32_h (a, len)
> + subroutine acc_present_or_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_present_or_copyin_64_h (a, len)
> + subroutine acc_present_or_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_present_or_copyin_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_present_or_copyin_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_create_32_h (a, len)
> + subroutine acc_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_create_64_h (a, len)
> + subroutine acc_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_create_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_create_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_present_or_create_32_h (a, len)
> + subroutine acc_present_or_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_present_or_create_64_h (a, len)
> + subroutine acc_present_or_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_present_or_create_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_present_or_create_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_copyout_32_h (a, len)
> + subroutine acc_copyout_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyout_64_h (a, len)
> + subroutine acc_copyout_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyout_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyout_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_copyout_finalize_32_h (a, len)
> + subroutine acc_copyout_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyout_finalize_64_h (a, len)
> + subroutine acc_copyout_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyout_finalize_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyout_finalize_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_delete_32_h (a, len)
> + subroutine acc_delete_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_delete_64_h (a, len)
> + subroutine acc_delete_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_delete_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_delete_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_delete_finalize_32_h (a, len)
> + subroutine acc_delete_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_delete_finalize_64_h (a, len)
> + subroutine acc_delete_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_delete_finalize_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_delete_finalize_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_update_device_32_h (a, len)
> + subroutine acc_update_device_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_update_device_64_h (a, len)
> + subroutine acc_update_device_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_update_device_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_update_device_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - subroutine acc_update_self_32_h (a, len)
> + subroutine acc_update_self_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_update_self_64_h (a, len)
> + subroutine acc_update_self_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_update_self_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_update_self_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
>
> - function acc_is_present_32_h (a, len)
> + function acc_is_present_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> logical acc_is_present_32_h
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end function
>
> - function acc_is_present_64_h (a, len)
> + function acc_is_present_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> logical acc_is_present_64_h
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end function
>
> - function acc_is_present_array_h (a)
> + function acc_is_present_array_h (data_arg)
> logical acc_is_present_array_h
> - type (*), dimension (..), contiguous :: a
> + type (*), dimension (..), contiguous :: data_arg
> end function
>
> - subroutine acc_copyin_async_32_h (a, len, async)
> + subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyin_async_64_h (a, len, async)
> + subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyin_async_array_h (a, async)
> + subroutine acc_copyin_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_create_async_32_h (a, len, async)
> + subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_create_async_64_h (a, len, async)
> + subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_create_async_array_h (a, async)
> + subroutine acc_create_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyout_async_32_h (a, len, async)
> + subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyout_async_64_h (a, len, async)
> + subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyout_async_array_h (a, async)
> + subroutine acc_copyout_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_delete_async_32_h (a, len, async)
> + subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_delete_async_64_h (a, len, async)
> + subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_delete_async_array_h (a, async)
> + subroutine acc_delete_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_device_async_32_h (a, len, async)
> + subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_device_async_64_h (a, len, async)
> + subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_device_async_array_h (a, async)
> + subroutine acc_update_device_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_self_async_32_h (a, len, async)
> + subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_self_async_64_h (a, len, async)
> + subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_self_async_array_h (a, async)
> + subroutine acc_update_self_async_array_h (data_arg, async_arg)
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface
> - function acc_get_num_devices_l (devicetype) &
> + function acc_get_num_devices_l (dev_type) &
> bind (C, name = "acc_get_num_devices")
> use iso_c_binding, only: c_int
> integer (c_int) :: acc_get_num_devices_l
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end function
>
> - subroutine acc_set_device_type_l (devicetype) &
> + subroutine acc_set_device_type_l (dev_type) &
> bind (C, name = "acc_set_device_type")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end subroutine
>
> function acc_get_device_type_l () &
> @@ -527,44 +527,44 @@ module openacc_internal
> integer (c_int) :: acc_get_device_type_l
> end function
>
> - subroutine acc_set_device_num_l (devicenum, devicetype) &
> + subroutine acc_set_device_num_l (dev_num, dev_type) &
> bind (C, name = "acc_set_device_num")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: devicenum, devicetype
> + integer (c_int), value :: dev_num, dev_type
> end subroutine
>
> - function acc_get_device_num_l (devicetype) &
> + function acc_get_device_num_l (dev_type) &
> bind (C, name = "acc_get_device_num")
> use iso_c_binding, only: c_int
> integer (c_int) :: acc_get_device_num_l
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end function
>
> - function acc_get_property_l (devicenum, devicetype, property) &
> + function acc_get_property_l (dev_num, dev_type, property) &
> bind (C, name = "acc_get_property")
> use iso_c_binding, only: c_int, c_size_t
> implicit none (type, external)
> integer (c_size_t) :: acc_get_property_l
> - integer (c_int), value :: devicenum
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_num
> + integer (c_int), value :: dev_type
> integer (c_int), value :: property
> end function
>
> - function acc_get_property_string_l (devicenum, devicetype, property) &
> + function acc_get_property_string_l (dev_num, dev_type, property) &
> bind (C, name = "acc_get_property_string")
> use iso_c_binding, only: c_int, c_ptr
> implicit none (type, external)
> type (c_ptr) :: acc_get_property_string_l
> - integer (c_int), value :: devicenum
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_num
> + integer (c_int), value :: dev_type
> integer (c_int), value :: property
> end function
>
> - function acc_async_test_l (a) &
> + function acc_async_test_l (data_arg) &
> bind (C, name = "acc_async_test")
> use iso_c_binding, only: c_int
> integer (c_int) :: acc_async_test_l
> - integer (c_int), value :: a
> + integer (c_int), value :: data_arg
> end function
>
> function acc_async_test_all_l () &
> @@ -573,16 +573,16 @@ module openacc_internal
> integer (c_int) :: acc_async_test_all_l
> end function
>
> - subroutine acc_wait_l (a) &
> + subroutine acc_wait_l (data_arg) &
> bind (C, name = "acc_wait")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: a
> + integer (c_int), value :: data_arg
> end subroutine
>
> - subroutine acc_wait_async_l (arg, async) &
> + subroutine acc_wait_async_l (wait_arg, async_arg) &
> bind (C, name = "acc_wait_async")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: arg, async
> + integer (c_int), value :: wait_arg, async_arg
> end subroutine
>
> subroutine acc_wait_all_l () &
> @@ -590,172 +590,172 @@ module openacc_internal
> use iso_c_binding, only: c_int
> end subroutine
>
> - subroutine acc_wait_all_async_l (async) &
> + subroutine acc_wait_all_async_l (async_arg) &
> bind (C, name = "acc_wait_all_async")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: async
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_init_l (devicetype) &
> + subroutine acc_init_l (dev_type) &
> bind (C, name = "acc_init")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end subroutine
>
> - subroutine acc_shutdown_l (devicetype) &
> + subroutine acc_shutdown_l (dev_type) &
> bind (C, name = "acc_shutdown")
> use iso_c_binding, only: c_int
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end subroutine
>
> - function acc_on_device_l (devicetype) &
> + function acc_on_device_l (dev_type) &
> bind (C, name = "acc_on_device")
> use iso_c_binding, only: c_int
> integer (c_int) :: acc_on_device_l
> - integer (c_int), value :: devicetype
> + integer (c_int), value :: dev_type
> end function
>
> - subroutine acc_copyin_l (a, len) &
> + subroutine acc_copyin_l (data_arg, bytes) &
> bind (C, name = "acc_copyin")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_present_or_copyin_l (a, len) &
> + subroutine acc_present_or_copyin_l (data_arg, bytes) &
> bind (C, name = "acc_present_or_copyin")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_create_l (a, len) &
> + subroutine acc_create_l (data_arg, bytes) &
> bind (C, name = "acc_create")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_present_or_create_l (a, len) &
> + subroutine acc_present_or_create_l (data_arg, bytes) &
> bind (C, name = "acc_present_or_create")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_copyout_l (a, len) &
> + subroutine acc_copyout_l (data_arg, bytes) &
> bind (C, name = "acc_copyout")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_copyout_finalize_l (a, len) &
> + subroutine acc_copyout_finalize_l (data_arg, bytes) &
> bind (C, name = "acc_copyout_finalize")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_delete_l (a, len) &
> + subroutine acc_delete_l (data_arg, bytes) &
> bind (C, name = "acc_delete")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_delete_finalize_l (a, len) &
> + subroutine acc_delete_finalize_l (data_arg, bytes) &
> bind (C, name = "acc_delete_finalize")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_update_device_l (a, len) &
> + subroutine acc_update_device_l (data_arg, bytes) &
> bind (C, name = "acc_update_device")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - subroutine acc_update_self_l (a, len) &
> + subroutine acc_update_self_l (data_arg, bytes) &
> bind (C, name = "acc_update_self")
> use iso_c_binding, only: c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end subroutine
>
> - function acc_is_present_l (a, len) &
> + function acc_is_present_l (data_arg, bytes) &
> bind (C, name = "acc_is_present")
> use iso_c_binding, only: c_int32_t, c_size_t
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> integer (c_int32_t) :: acc_is_present_l
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> end function
>
> - subroutine acc_copyin_async_l (a, len, async) &
> + subroutine acc_copyin_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_copyin_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_create_async_l (a, len, async) &
> + subroutine acc_create_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_create_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_copyout_async_l (a, len, async) &
> + subroutine acc_copyout_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_copyout_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_delete_async_l (a, len, async) &
> + subroutine acc_delete_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_delete_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_update_device_async_l (a, len, async) &
> + subroutine acc_update_device_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_update_device_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
>
> - subroutine acc_update_self_async_l (a, len, async) &
> + subroutine acc_update_self_async_l (data_arg, bytes, async_arg) &
> bind (C, name = "acc_update_self_async")
> use iso_c_binding, only: c_size_t, c_int
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_size_t), value :: len
> - integer (c_int), value :: async
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_size_t), value :: bytes
> + integer (c_int), value :: async_arg
> end subroutine
> end interface
> end module openacc_internal
> @@ -1084,19 +1084,19 @@ module openacc
>
> end module openacc
>
> -function acc_get_num_devices_h (devicetype)
> +function acc_get_num_devices_h (dev_type)
> use openacc_internal, only: acc_get_num_devices_l
> use openacc_kinds
> integer acc_get_num_devices_h
> - integer (acc_device_kind) devicetype
> - acc_get_num_devices_h = acc_get_num_devices_l (devicetype)
> + integer (acc_device_kind) dev_type
> + acc_get_num_devices_h = acc_get_num_devices_l (dev_type)
> end function
>
> -subroutine acc_set_device_type_h (devicetype)
> +subroutine acc_set_device_type_h (dev_type)
> use openacc_internal, only: acc_set_device_type_l
> use openacc_kinds
> - integer (acc_device_kind) devicetype
> - call acc_set_device_type_l (devicetype)
> + integer (acc_device_kind) dev_type
> + call acc_set_device_type_l (dev_type)
> end subroutine
>
> function acc_get_device_type_h ()
> @@ -1106,41 +1106,41 @@ function acc_get_device_type_h ()
> acc_get_device_type_h = acc_get_device_type_l ()
> end function
>
> -subroutine acc_set_device_num_h (devicenum, devicetype)
> +subroutine acc_set_device_num_h (dev_num, dev_type)
> use openacc_internal, only: acc_set_device_num_l
> use openacc_kinds
> - integer devicenum
> - integer (acc_device_kind) devicetype
> - call acc_set_device_num_l (devicenum, devicetype)
> + integer dev_num
> + integer (acc_device_kind) dev_type
> + call acc_set_device_num_l (dev_num, dev_type)
> end subroutine
>
> -function acc_get_device_num_h (devicetype)
> +function acc_get_device_num_h (dev_type)
> use openacc_internal, only: acc_get_device_num_l
> use openacc_kinds
> integer acc_get_device_num_h
> - integer (acc_device_kind) devicetype
> - acc_get_device_num_h = acc_get_device_num_l (devicetype)
> + integer (acc_device_kind) dev_type
> + acc_get_device_num_h = acc_get_device_num_l (dev_type)
> end function
>
> -function acc_get_property_h (devicenum, devicetype, property)
> +function acc_get_property_h (dev_num, dev_type, property)
> use iso_c_binding, only: c_size_t
> use openacc_internal, only: acc_get_property_l
> use openacc_kinds
> implicit none (type, external)
> integer (c_size_t) :: acc_get_property_h
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> - acc_get_property_h = acc_get_property_l (devicenum, devicetype, property)
> + acc_get_property_h = acc_get_property_l (dev_num, dev_type, property)
> end function
>
> -subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
> +subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
> use iso_c_binding, only: c_char, c_size_t, c_ptr, c_f_pointer, c_associated
> use openacc_internal, only: acc_get_property_string_l
> use openacc_kinds
> implicit none (type, external)
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> character (*) :: string
>
> @@ -1156,7 +1156,7 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
> end function strlen
> end interface
>
> - cptr = acc_get_property_string_l (devicenum, devicetype, property)
> + cptr = acc_get_property_string_l (dev_num, dev_type, property)
> string = ""
> if (.not. c_associated (cptr)) then
> return
> @@ -1171,11 +1171,11 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
> end do
> end subroutine
>
> -function acc_async_test_h (arg)
> +function acc_async_test_h (wait_arg)
> use openacc_internal, only: acc_async_test_l
> logical acc_async_test_h
> - integer arg
> - acc_async_test_h = acc_async_test_l (arg) /= 0
> + integer wait_arg
> + acc_async_test_h = acc_async_test_l (wait_arg) /= 0
> end function
>
> function acc_async_test_all_h ()
> @@ -1184,16 +1184,16 @@ function acc_async_test_all_h ()
> acc_async_test_all_h = acc_async_test_all_l () /= 0
> end function
>
> -subroutine acc_wait_h (arg)
> +subroutine acc_wait_h (wait_arg)
> use openacc_internal, only: acc_wait_l
> - integer arg
> - call acc_wait_l (arg)
> + integer wait_arg
> + call acc_wait_l (wait_arg)
> end subroutine
>
> -subroutine acc_wait_async_h (arg, async)
> +subroutine acc_wait_async_h (wait_arg, async_arg)
> use openacc_internal, only: acc_wait_async_l
> - integer arg, async
> - call acc_wait_async_l (arg, async)
> + integer wait_arg, async_arg
> + call acc_wait_async_l (wait_arg, async_arg)
> end subroutine
>
> subroutine acc_wait_all_h ()
> @@ -1201,483 +1201,483 @@ subroutine acc_wait_all_h ()
> call acc_wait_all_l ()
> end subroutine
>
> -subroutine acc_wait_all_async_h (async)
> +subroutine acc_wait_all_async_h (async_arg)
> use openacc_internal, only: acc_wait_all_async_l
> - integer async
> - call acc_wait_all_async_l (async)
> + integer async_arg
> + call acc_wait_all_async_l (async_arg)
> end subroutine
>
> -subroutine acc_init_h (devicetype)
> +subroutine acc_init_h (dev_type)
> use openacc_internal, only: acc_init_l
> use openacc_kinds
> - integer (acc_device_kind) devicetype
> - call acc_init_l (devicetype)
> + integer (acc_device_kind) dev_type
> + call acc_init_l (dev_type)
> end subroutine
>
> -subroutine acc_shutdown_h (devicetype)
> +subroutine acc_shutdown_h (dev_type)
> use openacc_internal, only: acc_shutdown_l
> use openacc_kinds
> - integer (acc_device_kind) devicetype
> - call acc_shutdown_l (devicetype)
> + integer (acc_device_kind) dev_type
> + call acc_shutdown_l (dev_type)
> end subroutine
>
> -function acc_on_device_h (devicetype)
> +function acc_on_device_h (dev_type)
> use openacc_internal, only: acc_on_device_l
> use openacc_kinds
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> logical acc_on_device_h
> - acc_on_device_h = acc_on_device_l (devicetype) /= 0
> + acc_on_device_h = acc_on_device_l (dev_type) /= 0
> end function
>
> -subroutine acc_copyin_32_h (a, len)
> +subroutine acc_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_copyin_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_copyin_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyin_64_h (a, len)
> +subroutine acc_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_copyin_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_copyin_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyin_array_h (a)
> +subroutine acc_copyin_array_h (data_arg)
> use openacc_internal, only: acc_copyin_l
> - type (*), dimension (..), contiguous :: a
> - call acc_copyin_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_copyin_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_present_or_copyin_32_h (a, len)
> +subroutine acc_present_or_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_present_or_copyin_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_present_or_copyin_64_h (a, len)
> +subroutine acc_present_or_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_present_or_copyin_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_present_or_copyin_array_h (a)
> +subroutine acc_present_or_copyin_array_h (data_arg)
> use openacc_internal, only: acc_present_or_copyin_l
> - type (*), dimension (..), contiguous :: a
> - call acc_present_or_copyin_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_present_or_copyin_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_create_32_h (a, len)
> +subroutine acc_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_create_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_create_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_create_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_create_64_h (a, len)
> +subroutine acc_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_create_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_create_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_create_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_create_array_h (a)
> +subroutine acc_create_array_h (data_arg)
> use openacc_internal, only: acc_create_l
> - type (*), dimension (..), contiguous :: a
> - call acc_create_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_create_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_present_or_create_32_h (a, len)
> +subroutine acc_present_or_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_present_or_create_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_present_or_create_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_present_or_create_64_h (a, len)
> +subroutine acc_present_or_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_present_or_create_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_present_or_create_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_present_or_create_array_h (a)
> +subroutine acc_present_or_create_array_h (data_arg)
> use openacc_internal, only: acc_present_or_create_l
> - type (*), dimension (..), contiguous :: a
> - call acc_present_or_create_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_present_or_create_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_copyout_32_h (a, len)
> +subroutine acc_copyout_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_copyout_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_copyout_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyout_64_h (a, len)
> +subroutine acc_copyout_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_copyout_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_copyout_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyout_array_h (a)
> +subroutine acc_copyout_array_h (data_arg)
> use openacc_internal, only: acc_copyout_l
> - type (*), dimension (..), contiguous :: a
> - call acc_copyout_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_copyout_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_copyout_finalize_32_h (a, len)
> +subroutine acc_copyout_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_copyout_finalize_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyout_finalize_64_h (a, len)
> +subroutine acc_copyout_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_copyout_finalize_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_copyout_finalize_array_h (a)
> +subroutine acc_copyout_finalize_array_h (data_arg)
> use openacc_internal, only: acc_copyout_finalize_l
> - type (*), dimension (..), contiguous :: a
> - call acc_copyout_finalize_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_copyout_finalize_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_delete_32_h (a, len)
> +subroutine acc_delete_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_delete_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_delete_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_delete_64_h (a, len)
> +subroutine acc_delete_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_delete_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_delete_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_delete_array_h (a)
> +subroutine acc_delete_array_h (data_arg)
> use openacc_internal, only: acc_delete_l
> - type (*), dimension (..), contiguous :: a
> - call acc_delete_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_delete_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_delete_finalize_32_h (a, len)
> +subroutine acc_delete_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_delete_finalize_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_delete_finalize_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_delete_finalize_64_h (a, len)
> +subroutine acc_delete_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_delete_finalize_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_delete_finalize_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_delete_finalize_array_h (a)
> +subroutine acc_delete_finalize_array_h (data_arg)
> use openacc_internal, only: acc_delete_finalize_l
> - type (*), dimension (..), contiguous :: a
> - call acc_delete_finalize_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_delete_finalize_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_update_device_32_h (a, len)
> +subroutine acc_update_device_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_update_device_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_update_device_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_update_device_64_h (a, len)
> +subroutine acc_update_device_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_update_device_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_update_device_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_update_device_array_h (a)
> +subroutine acc_update_device_array_h (data_arg)
> use openacc_internal, only: acc_update_device_l
> - type (*), dimension (..), contiguous :: a
> - call acc_update_device_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_update_device_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -subroutine acc_update_self_32_h (a, len)
> +subroutine acc_update_self_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_update_self_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - call acc_update_self_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_update_self_64_h (a, len)
> +subroutine acc_update_self_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_update_self_l
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - call acc_update_self_l (a, int (len, kind = c_size_t))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
> end subroutine
>
> -subroutine acc_update_self_array_h (a)
> +subroutine acc_update_self_array_h (data_arg)
> use openacc_internal, only: acc_update_self_l
> - type (*), dimension (..), contiguous :: a
> - call acc_update_self_l (a, sizeof (a))
> + type (*), dimension (..), contiguous :: data_arg
> + call acc_update_self_l (data_arg, sizeof (data_arg))
> end subroutine
>
> -function acc_is_present_32_h (a, len)
> +function acc_is_present_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t, c_size_t
> use openacc_internal, only: acc_is_present_l
> logical acc_is_present_32_h
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - acc_is_present_32_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + acc_is_present_32_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
> end function
>
> -function acc_is_present_64_h (a, len)
> +function acc_is_present_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t, c_size_t
> use openacc_internal, only: acc_is_present_l
> logical acc_is_present_64_h
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - acc_is_present_64_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + acc_is_present_64_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
> end function
>
> -function acc_is_present_array_h (a)
> +function acc_is_present_array_h (data_arg)
> use openacc_internal, only: acc_is_present_l
> logical acc_is_present_array_h
> - type (*), dimension (..), contiguous :: a
> - acc_is_present_array_h = acc_is_present_l (a, sizeof (a)) /= 0
> + type (*), dimension (..), contiguous :: data_arg
> + acc_is_present_array_h = acc_is_present_l (data_arg, sizeof (data_arg)) /= 0
> end function
>
> -subroutine acc_copyin_async_32_h (a, len, async)
> +subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_copyin_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_copyin_async_64_h (a, len, async)
> +subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_copyin_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_copyin_async_array_h (a, async)
> +subroutine acc_copyin_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_copyin_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_copyin_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_copyin_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_create_async_32_h (a, len, async)
> +subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_create_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_create_async_64_h (a, len, async)
> +subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_create_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_create_async_array_h (a, async)
> +subroutine acc_create_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_create_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_create_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_create_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_copyout_async_32_h (a, len, async)
> +subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_copyout_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_copyout_async_64_h (a, len, async)
> +subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_copyout_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_copyout_async_array_h (a, async)
> +subroutine acc_copyout_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_copyout_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_copyout_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_copyout_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_delete_async_32_h (a, len, async)
> +subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_delete_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_delete_async_64_h (a, len, async)
> +subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_delete_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_delete_async_array_h (a, async)
> +subroutine acc_delete_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_delete_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_delete_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_delete_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_device_async_32_h (a, len, async)
> +subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_update_device_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_device_async_64_h (a, len, async)
> +subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_update_device_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_device_async_array_h (a, async)
> +subroutine acc_update_device_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_update_device_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_update_device_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_update_device_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_self_async_32_h (a, len, async)
> +subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t, c_size_t, c_int
> use openacc_internal, only: acc_update_self_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> - call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_self_async_64_h (a, len, async)
> +subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t, c_size_t, c_int
> use openacc_internal, only: acc_update_self_async_l
> use openacc_kinds, only: acc_handle_kind
> - !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> - call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
> + !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> + call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
> end subroutine
>
> -subroutine acc_update_self_async_array_h (a, async)
> +subroutine acc_update_self_async_array_h (data_arg, async_arg)
> use iso_c_binding, only: c_int
> use openacc_internal, only: acc_update_self_async_l
> use openacc_kinds, only: acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async
> - call acc_update_self_async_l (a, sizeof (a), int (async, kind = c_int))
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> + call acc_update_self_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
> end subroutine
> diff --git a/libgomp/openacc_lib.h b/libgomp/openacc_lib.h
> index 913c3f1aa3d..07f6da1bad2 100644
> --- a/libgomp/openacc_lib.h
> +++ b/libgomp/openacc_lib.h
> @@ -73,17 +73,17 @@
> integer, parameter :: openacc_version = 201711
>
> interface acc_get_num_devices
> - function acc_get_num_devices_h (devicetype)
> + function acc_get_num_devices_h (dev_type)
> import acc_device_kind
> integer acc_get_num_devices_h
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end function
> end interface
>
> interface acc_set_device_type
> - subroutine acc_set_device_type_h (devicetype)
> + subroutine acc_set_device_type_h (dev_type)
> import acc_device_kind
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
> end interface
>
> @@ -95,50 +95,50 @@
> end interface
>
> interface acc_set_device_num
> - subroutine acc_set_device_num_h (devicenum, devicetype)
> + subroutine acc_set_device_num_h (dev_num, dev_type)
> import acc_device_kind
> - integer devicenum
> - integer (acc_device_kind) devicetype
> + integer dev_num
> + integer (acc_device_kind) dev_type
> end subroutine
> end interface
>
> interface acc_get_device_num
> - function acc_get_device_num_h (devicetype)
> + function acc_get_device_num_h (dev_type)
> import acc_device_kind
> integer acc_get_device_num_h
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end function
> end interface
>
> interface acc_get_property
> - function acc_get_property_h (devicenum, devicetype, &
> + function acc_get_property_h (dev_num, dev_type, &
> & property)
> use iso_c_binding, only: c_size_t
> import acc_device_kind, acc_device_property_kind
> implicit none (type, external)
> integer (c_size_t) :: acc_get_property_h
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> end function
> end interface
>
> interface acc_get_property_string
> - subroutine acc_get_property_string_h (devicenum, devicetype, &
> + subroutine acc_get_property_string_h (dev_num, dev_type, &
> & property, string)
> import acc_device_kind, acc_device_property_kind
> implicit none (type, external)
> - integer, value :: devicenum
> - integer (acc_device_kind), value :: devicetype
> + integer, value :: dev_num
> + integer (acc_device_kind), value :: dev_type
> integer (acc_device_property_kind), value :: property
> character (*) :: string
> end subroutine
> end interface
>
> interface acc_async_test
> - function acc_async_test_h (arg)
> + function acc_async_test_h (wait_arg)
> logical acc_async_test_h
> - integer arg
> + integer wait_arg
> end function
> end interface
>
> @@ -149,8 +149,8 @@
> end interface
>
> interface acc_wait
> - subroutine acc_wait_h (arg)
> - integer arg
> + subroutine acc_wait_h (wait_arg)
> + integer wait_arg
> end subroutine
> end interface
>
> @@ -160,8 +160,8 @@
> end interface
>
> interface acc_wait_async
> - subroutine acc_wait_async_h (arg, async)
> - integer arg, async
> + subroutine acc_wait_async_h (wait_arg, async_arg)
> + integer wait_arg, async_arg
> end subroutine
> end interface
>
> @@ -177,30 +177,30 @@
> end interface
>
> interface acc_wait_all_async
> - subroutine acc_wait_all_async_h (async)
> - integer async
> + subroutine acc_wait_all_async_h (async_arg)
> + integer async_arg
> end subroutine
> end interface
>
> interface acc_init
> - subroutine acc_init_h (devicetype)
> + subroutine acc_init_h (dev_type)
> import acc_device_kind
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
> end interface
>
> interface acc_shutdown
> - subroutine acc_shutdown_h (devicetype)
> + subroutine acc_shutdown_h (dev_type)
> import acc_device_kind
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end subroutine
> end interface
>
> interface acc_on_device
> - function acc_on_device_h (devicetype)
> + function acc_on_device_h (dev_type)
> import acc_device_kind
> logical acc_on_device_h
> - integer (acc_device_kind) devicetype
> + integer (acc_device_kind) dev_type
> end function
> end interface
>
> @@ -219,42 +219,42 @@
> end interface
>
> interface acc_copyin
> - subroutine acc_copyin_32_h (a, len)
> + subroutine acc_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyin_64_h (a, len)
> + subroutine acc_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyin_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyin_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_present_or_copyin
> - subroutine acc_present_or_copyin_32_h (a, len)
> + subroutine acc_present_or_copyin_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_present_or_copyin_64_h (a, len)
> + subroutine acc_present_or_copyin_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_present_or_copyin_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_present_or_copyin_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> @@ -265,42 +265,42 @@
> end interface
>
> interface acc_create
> - subroutine acc_create_32_h (a, len)
> + subroutine acc_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_create_64_h (a, len)
> + subroutine acc_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_create_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_create_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_present_or_create
> - subroutine acc_present_or_create_32_h (a, len)
> + subroutine acc_present_or_create_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_present_or_create_64_h (a, len)
> + subroutine acc_present_or_create_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_present_or_create_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_present_or_create_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> @@ -311,122 +311,122 @@
> end interface
>
> interface acc_copyout
> - subroutine acc_copyout_32_h (a, len)
> + subroutine acc_copyout_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyout_64_h (a, len)
> + subroutine acc_copyout_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyout_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyout_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_copyout_finalize
> - subroutine acc_copyout_finalize_32_h (a, len)
> + subroutine acc_copyout_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_copyout_finalize_64_h (a, len)
> + subroutine acc_copyout_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_copyout_finalize_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_copyout_finalize_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_delete
> - subroutine acc_delete_32_h (a, len)
> + subroutine acc_delete_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_delete_64_h (a, len)
> + subroutine acc_delete_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_delete_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_delete_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_delete_finalize
> - subroutine acc_delete_finalize_32_h (a, len)
> + subroutine acc_delete_finalize_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_delete_finalize_64_h (a, len)
> + subroutine acc_delete_finalize_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_delete_finalize_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_delete_finalize_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_update_device
> - subroutine acc_update_device_32_h (a, len)
> + subroutine acc_update_device_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_update_device_64_h (a, len)
> + subroutine acc_update_device_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_update_device_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_update_device_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> interface acc_update_self
> - subroutine acc_update_self_32_h (a, len)
> + subroutine acc_update_self_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end subroutine
>
> - subroutine acc_update_self_64_h (a, len)
> + subroutine acc_update_self_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end subroutine
>
> - subroutine acc_update_self_array_h (a)
> - type (*), dimension (..), contiguous :: a
> + subroutine acc_update_self_array_h (data_arg)
> + type (*), dimension (..), contiguous :: data_arg
> end subroutine
> end interface
>
> @@ -460,25 +460,25 @@
> end interface
>
> interface acc_is_present
> - function acc_is_present_32_h (a, len)
> + function acc_is_present_32_h (data_arg, bytes)
> use iso_c_binding, only: c_int32_t
> logical acc_is_present_32_h
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> end function
>
> - function acc_is_present_64_h (a, len)
> + function acc_is_present_64_h (data_arg, bytes)
> use iso_c_binding, only: c_int64_t
> logical acc_is_present_64_h
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> end function
>
> - function acc_is_present_array_h (a)
> + function acc_is_present_array_h (data_arg)
> logical acc_is_present_array_h
> - type (*), dimension (..), contiguous :: a
> + type (*), dimension (..), contiguous :: data_arg
> end function
> end interface
>
> @@ -529,157 +529,161 @@
> end interface
>
> interface acc_copyin_async
> - subroutine acc_copyin_async_32_h (a, len, async)
> + subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyin_async_64_h (a, len, async)
> + subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyin_async_array_h (a, async_)
> + subroutine acc_copyin_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface acc_create_async
> - subroutine acc_create_async_32_h (a, len, async)
> + subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_create_async_64_h (a, len, async)
> + subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_create_async_array_h (a, async_)
> + subroutine acc_create_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface acc_copyout_async
> - subroutine acc_copyout_async_32_h (a, len, async)
> + subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyout_async_64_h (a, len, async)
> + subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_copyout_async_array_h (a, async_)
> + subroutine acc_copyout_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface acc_delete_async
> - subroutine acc_delete_async_32_h (a, len, async)
> + subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_delete_async_64_h (a, len, async)
> + subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_delete_async_array_h (a, async_)
> + subroutine acc_delete_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface acc_update_device_async
> - subroutine acc_update_device_async_32_h (a, len, async)
> + subroutine acc_update_device_async_32_h (data_arg, bytes, &
> + & async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_device_async_64_h (a, len, async)
> + subroutine acc_update_device_async_64_h (data_arg, bytes, &
> + & async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_device_async_array_h (a, async_)
> + subroutine acc_update_device_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
>
> interface acc_update_self_async
> - subroutine acc_update_self_async_32_h (a, len, async)
> + subroutine acc_update_self_async_32_h (data_arg, bytes, &
> + & async_arg)
> use iso_c_binding, only: c_int32_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int32_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int32_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_self_async_64_h (a, len, async)
> + subroutine acc_update_self_async_64_h (data_arg, bytes, &
> + & async_arg)
> use iso_c_binding, only: c_int64_t
> import acc_handle_kind
> -!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
> - type (*), dimension (*) :: a
> - integer (c_int64_t) len
> - integer (acc_handle_kind) async
> +!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
> + type (*), dimension (*) :: data_arg
> + integer (c_int64_t) bytes
> + integer (acc_handle_kind) async_arg
> end subroutine
>
> - subroutine acc_update_self_async_array_h (a, async_)
> + subroutine acc_update_self_async_array_h (data_arg, async_arg)
> import acc_handle_kind
> - type (*), dimension (..), contiguous :: a
> - integer (acc_handle_kind) async_
> + type (*), dimension (..), contiguous :: data_arg
> + integer (acc_handle_kind) async_arg
> end subroutine
> end interface
Hi Thomas,
Thomas Schwinge wrote:
> On 2024-02-27T20:11:30+0100, Tobias Burnus<tburnus@baylibre.com> wrote:
>> The attached patch updates the manual to match OpenACC 3.3
>> specification for the implemented routines.
> But not update references to OpenACC 3.3, too?
As the change is not really visible (except when using Fortran
keywords), it was not really clear to me whether the reference should be
either changed to *or* augmented by the OpenACC 3.1 *or* 3.3
specification reference.
What do you prefer? 3.1 or 3.3, in addition or instead of the existing
2.x (?) references?
> The questions is whether we want to do this now, or once we actually
> support 3.1 or 3.3; what was your intention for preparing this now?
Fallout of some bug fixes I intended to to in the .texi file, which in
turn was a fallout of the trivial addition of the 3.3 interfaces for
Fortran. Well, then I realized that 3.1 changed the argument names as well.
I think we should at least do the .texi bug fixes. Additionally, those
'type, dimension(:[,:]...)' look very odd – thus, I would be inclined to
do those as well.
Otherwise, it is more the question when to break the keyword= API;
fortunately, it is not an ABI issue as the compiler just uses it to
reorder the arguments back to the original declaration.
>> NOTE: Those argument names *do* have an effect and can be a breaking
>> change as Fortran permits using the arg name in the call, e.g.,
>> call acc_copyin(a=myVar) ! old
>> must now be called either as
>> call acc_copyin(data_arg=myVar) ! new
>> or as
>> call acc_copyin(myVar) ! works with old and new names
>> As the latter is way more common, the spec change hopefully does not
>> break too many programs.
> I wonder: would it happen to be possible via "Fortran interface magic" to
> actually support several variants of named arguments? I agree we can
> drop any bogus GCC-local variants, but is it possible to support all the
> official variants?
Obviously not as the default (Fortran + real world) is to use no
keywords – and then the two variants become ambiguous. Therefore,
Fortran doesn't permit to combine two specific functions that only
differ in this aspect.
If a real-world program uses the keywords by ill chance, it still had
the very same problem depending on the compiler version and vendor as
that's an upstream spec change.
The simple solution on the program side is just to drop the keyword –
then it will work with either variant.
I think only very programs are affected – possibly even none. And I
wonder how other compilers handle this, given that they also started
implementing (selected) OpenACC 2.7 and 3.x features (including 3.3, as
real-world programs proof).
>> And, finally, it synced over all named constants from openacc.f90 to
>> config/accel/openacc.f90.
> I don't think that's necessary: as I understand, that one's for
> 'acc_on_device' only?
I think you are right — unless 'f951' is run on the device side, which
won't happen for offloading, the accelerator version of the module file
is not read – only the host version. The named constants will be
expanded early to their numeric value and only the procedure calls
remain. — Of those, only 'acc_on_device' has to be available on the
device side and — hence, it is used at lto/link time by the device-side
of the linker (by linking libgomp.a).
Thus, I withdraw this change as not being required, not harming, but
wasting some GCC-build-time (only) file storage size and CPU cycles.
Tobias
OpenACC: Update libgomp.texi + openacc{.f90,_lib.h} for 3.1 arg-name changes
This commit handles the following OpenACC 3.1 changes:
First, several argument names were renamed: len -> bytes, a -> data_arg,
async -> async_arg, arg -> wait_arg, devicenum -> dev_num,
and devicetype -> dev_type.
Secondly, it also changed the slightly odd 'type, dimension(:[,:]...)'
to 'type(*), dimension(..)'.
The commit also fixes some minor issues as encountered (wrong function
name in Fortran part of 'acc_async_test_all', bogus 'void' for Fortran,
missing 'void' for C).
Those argument changes had to be also put into the Fortran files, which
this commit does.
NOTE: Those argument names *do* have an effect and can be a breaking
change as Fortran permits using the arg name in the call, e.g.,
call acc_copyin(a=myVar) ! old
must now be called either as
call acc_copyin(data_arg=myVar) ! new
or as
call acc_copyin(myVar) ! works with old and new names
As the latter is way more common, the spec change hopefully does not
break too many programs.
And, finally, it synced over all named constants from openacc.f90 to
config/accel/openacc.f90.
libgomp/ChangeLog:
* libgomp.texi (OpenACC Runtime Library Routines): Minor fixes
and update to 3.1 routine argument names.
* openacc_lib.h: Update routine argument names.
* openacc.f90: Likewise.
* config/accel/openacc.f90: Likewise; add all named constants
that have been accumulated so far.
libgomp/config/accel/openacc.f90 | 42 +-
libgomp/libgomp.texi | 504 ++++++++--------
libgomp/openacc.f90 | 1200 +++++++++++++++++++-------------------
libgomp/openacc_lib.h | 438 +++++++-------
4 files changed, 1108 insertions(+), 1076 deletions(-)
@@ -53,6 +53,23 @@ module openacc_kinds
integer (acc_device_kind), parameter :: acc_device_nvidia = 5
integer (acc_device_kind), parameter :: acc_device_radeon = 8
+ integer, parameter :: acc_device_property_kind = int32
+ ! OpenACC 2.6/2.7/3.0 used acc_device_property; in a spec update the
+ ! missing '_kind' was added for consistency. For backward compatibility, keep:
+ integer, parameter :: acc_device_property = acc_device_property_kind
+
+ ! Keep in sync with 'libgomp/libgomp-plugin.h:goacc_property'.
+ integer (acc_device_property_kind), parameter :: acc_property_memory = 1
+ integer (acc_device_property_kind), parameter :: acc_property_free_memory = 2
+ integer (acc_device_property_kind), parameter :: acc_property_name = int(Z'10001')
+ integer (acc_device_property_kind), parameter :: acc_property_vendor = int(Z'10002')
+ integer (acc_device_property_kind), parameter :: acc_property_driver = int(Z'10003')
+
+ integer, parameter :: acc_handle_kind = int32
+
+ ! Keep in sync with include/gomp-constants.h.
+ integer (acc_handle_kind), parameter :: acc_async_noval = -1
+ integer (acc_handle_kind), parameter :: acc_async_sync = -2
end module openacc_kinds
module openacc_internal
@@ -60,19 +77,19 @@ module openacc_internal
implicit none
interface
- function acc_on_device_h (devicetype)
+ function acc_on_device_h (dev_type)
import
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
logical acc_on_device_h
end function
end interface
interface
- function acc_on_device_l (devicetype) &
+ function acc_on_device_l (dev_type) &
bind (C, name = "acc_on_device")
use iso_c_binding, only: c_int
integer (c_int) :: acc_on_device_l
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end function
end interface
end module openacc_internal
@@ -89,18 +106,29 @@ module openacc
public :: acc_device_none, acc_device_default, acc_device_host
public :: acc_device_not_host, acc_device_nvidia, acc_device_radeon
+ public :: acc_device_property_kind, acc_device_property
+ public :: acc_property_memory, acc_property_free_memory
+ public :: acc_property_name, acc_property_vendor, acc_property_driver
+
+ public :: acc_handle_kind
+ public :: acc_async_noval, acc_async_sync
+
+ public :: openacc_version
+
public :: acc_on_device
+ integer, parameter :: openacc_version = 201711
+
interface acc_on_device
procedure :: acc_on_device_h
end interface
end module openacc
-function acc_on_device_h (devicetype)
+function acc_on_device_h (dev_type)
use openacc_internal, only: acc_on_device_l
use openacc_kinds
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
logical acc_on_device_h
- acc_on_device_h = acc_on_device_l (devicetype) /= 0
+ acc_on_device_h = acc_on_device_l (dev_type) /= 0
end function
@@ -4271,17 +4271,17 @@ API routines for the OpenACC Profiling Interface.
@table @asis
@item @emph{Description}
This function returns a value indicating the number of devices available
-for the device type specified in @var{devicetype}.
+for the device type specified in @var{dev_type}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{int acc_get_num_devices(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(devicetype)}
-@item @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{integer function acc_get_num_devices(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@end multitable
@item @emph{Reference}:
@@ -4296,17 +4296,17 @@ for the device type specified in @var{devicetype}.
@table @asis
@item @emph{Description}
This function indicates to the runtime library which device type, specified
-in @var{devicetype}, to use when executing a parallel or kernels region.
+in @var{dev_type}, to use when executing a parallel or kernels region.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_set_device_type(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_set_device_type(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(devicetype)}
-@item @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_set_device_type(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@end multitable
@item @emph{Reference}:
@@ -4336,8 +4336,8 @@ Interface}), that is, if the device is currently being initialized.
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_device_type(void)}
-@item @tab @code{integer(kind=acc_device_kind) acc_get_device_type}
+@item @emph{Interface}: @tab @code{function acc_get_device_type()}
+@item @tab @code{integer(acc_device_kind) acc_get_device_type}
@end multitable
@item @emph{Reference}:
@@ -4352,19 +4352,19 @@ Interface}), that is, if the device is currently being initialized.
@table @asis
@item @emph{Description}
This function will indicate to the runtime which device number,
-specified by @var{devicenum}, associated with the specified device
-type @var{devicetype}.
+specified by @var{dev_num}, associated with the specified device
+type @var{dev_type}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_set_device_num(int devicenum, acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_set_device_num(int dev_num, acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(devicenum, devicetype)}
-@item @tab @code{integer devicenum}
-@item @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_set_device_num(dev_num, dev_type)}
+@item @tab @code{integer dev_num}
+@item @tab @code{integer(acc_device_kind) dev_type}
@end multitable
@item @emph{Reference}:
@@ -4379,18 +4379,18 @@ type @var{devicetype}.
@table @asis
@item @emph{Description}
This function returns which device number associated with the specified device
-type @var{devicetype}, will be used when executing a parallel or kernels
+type @var{dev_type}, will be used when executing a parallel or kernels
region.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{int acc_get_device_num(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_device_num(devicetype)}
-@item @tab @code{integer(kind=acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{function acc_get_device_num(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@item @tab @code{integer acc_get_device_num}
@end multitable
@@ -4408,7 +4408,7 @@ region.
@table @asis
@item @emph{Description}
These routines return the value of the specified @var{property} for the
-device being queried according to @var{devicenum} and @var{devicetype}.
+device being queried according to @var{dev_num} and @var{dev_type}.
Integer-valued and string-valued properties are returned by
@code{acc_get_property} and @code{acc_get_property_string} respectively.
The Fortran @code{acc_get_property_string} subroutine returns the string
@@ -4425,19 +4425,19 @@ but might be removed in a future version of GCC.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{size_t acc_get_property(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
-@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int devicenum, acc_device_t devicetype, acc_device_property_t property);}
+@item @emph{Prototype}: @tab @code{size_t acc_get_property(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
+@item @emph{Prototype}: @tab @code{const char *acc_get_property_string(int dev_num, acc_device_t dev_type, acc_device_property_t property);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_get_property(devicenum, devicetype, property)}
-@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(devicenum, devicetype, property, string)}
+@item @emph{Interface}: @tab @code{function acc_get_property(dev_num, dev_type, property)}
+@item @emph{Interface}: @tab @code{subroutine acc_get_property_string(dev_num, dev_type, property, string)}
@item @tab @code{use ISO_C_Binding, only: c_size_t}
-@item @tab @code{integer devicenum}
-@item @tab @code{integer(kind=acc_device_kind) devicetype}
-@item @tab @code{integer(kind=acc_device_property_kind) property}
-@item @tab @code{integer(kind=c_size_t) acc_get_property}
+@item @tab @code{integer dev_num}
+@item @tab @code{integer(acc_device_kind) dev_type}
+@item @tab @code{integer(acc_device_property_kind) property}
+@item @tab @code{integer(c_size_t) acc_get_property}
@item @tab @code{character(*) string}
@end multitable
@@ -4453,20 +4453,20 @@ but might be removed in a future version of GCC.
@table @asis
@item @emph{Description}
This function tests for completion of the asynchronous operation specified
-in @var{arg}. In C/C++, a non-zero value is returned to indicate
+in @var{wait_arg}. In C/C++, a non-zero value is returned to indicate
the specified asynchronous operation has completed while Fortran returns
@code{true}. If the asynchronous operation has not completed, C/C++ returns
zero and Fortran returns @code{false}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_async_test(int arg);}
+@item @emph{Prototype}: @tab @code{int acc_async_test(int wait_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_async_test(arg)}
-@item @tab @code{integer(kind=acc_handle_kind) arg}
+@item @emph{Interface}: @tab @code{function acc_async_test(wait_arg)}
+@item @tab @code{integer(acc_handle_kind) wait_arg}
@item @tab @code{logical acc_async_test}
@end multitable
@@ -4494,8 +4494,8 @@ Fortran returns @code{false}.
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_async_test()}
-@item @tab @code{logical acc_get_device_num}
+@item @emph{Interface}: @tab @code{function acc_async_test_all()}
+@item @tab @code{logical acc_async_test_all}
@end multitable
@item @emph{Reference}:
@@ -4510,20 +4510,20 @@ Fortran returns @code{false}.
@table @asis
@item @emph{Description}
This function waits for completion of the asynchronous operation
-specified in @var{arg}.
+specified in @var{wait_arg}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait(arg);}
-@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait(arg);}
+@item @emph{Prototype}: @tab @code{void acc_wait(wait_arg);}
+@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait(wait_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait(arg)}
-@item @tab @code{integer(acc_handle_kind) arg}
-@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(arg)}
-@item @tab @code{integer(acc_handle_kind) arg}
+@item @emph{Interface}: @tab @code{subroutine acc_wait(wait_arg)}
+@item @tab @code{integer(acc_handle_kind) wait_arg}
+@item @emph{Interface (OpenACC 1.0 compatibility)}: @tab @code{subroutine acc_async_wait(wait_arg)}
+@item @tab @code{integer(acc_handle_kind) wait_arg}
@end multitable
@item @emph{Reference}:
@@ -4541,8 +4541,8 @@ This function waits for the completion of all asynchronous operations.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_all(void);}
-@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{acc_async_wait_all(void);}
+@item @emph{Prototype}: @tab @code{void acc_wait_all(void);}
+@item @emph{Prototype (OpenACC 1.0 compatibility)}: @tab @code{void acc_async_wait_all(void);}
@end multitable
@item @emph{Fortran}:
@@ -4562,19 +4562,19 @@ This function waits for the completion of all asynchronous operations.
@section @code{acc_wait_all_async} -- Wait for completion of all asynchronous operations.
@table @asis
@item @emph{Description}
-This function enqueues a wait operation on the queue @var{async} for any
+This function enqueues a wait operation on the queue @var{async_arg} for any
and all asynchronous operations that have been previously enqueued on
any queue.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_all_async(int async);}
+@item @emph{Prototype}: @tab @code{void acc_wait_all_async(int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async)}
-@item @tab @code{integer(acc_handle_kind) async}
+@item @emph{Interface}: @tab @code{subroutine acc_wait_all_async(async_arg)}
+@item @tab @code{integer(acc_handle_kind) async_arg}
@end multitable
@item @emph{Reference}:
@@ -4588,18 +4588,18 @@ any queue.
@section @code{acc_wait_async} -- Wait for completion of asynchronous operations.
@table @asis
@item @emph{Description}
-This function enqueues a wait operation on queue @var{async} for any and all
-asynchronous operations enqueued on queue @var{arg}.
+This function enqueues a wait operation on queue @var{async_arg} for any and all
+asynchronous operations enqueued on queue @var{wait_arg}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_wait_async(int arg, int async);}
+@item @emph{Prototype}: @tab @code{void acc_wait_async(int wait_arg, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_wait_async(arg, async)}
-@item @tab @code{integer(acc_handle_kind) arg, async}
+@item @emph{Interface}: @tab @code{subroutine acc_wait_async(wait_arg, async_arg)}
+@item @tab @code{integer(acc_handle_kind) wait_arg, async_arg}
@end multitable
@item @emph{Reference}:
@@ -4614,17 +4614,17 @@ asynchronous operations enqueued on queue @var{arg}.
@table @asis
@item @emph{Description}
This function initializes the runtime for the device type specified in
-@var{devicetype}.
+@var{dev_type}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_init(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_init(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_init(devicetype)}
-@item @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_init(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@end multitable
@item @emph{Reference}:
@@ -4639,17 +4639,17 @@ This function initializes the runtime for the device type specified in
@table @asis
@item @emph{Description}
This function shuts down the runtime for the device type specified in
-@var{devicetype}.
+@var{dev_type}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_shutdown(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_shutdown(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_shutdown(devicetype)}
-@item @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{subroutine acc_shutdown(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@end multitable
@item @emph{Reference}:
@@ -4664,7 +4664,7 @@ This function shuts down the runtime for the device type specified in
@table @asis
@item @emph{Description}:
This function returns whether the program is executing on a particular
-device specified in @var{devicetype}. In C/C++ a non-zero value is
+device specified in @var{dev_type}. In C/C++ a non-zero value is
returned to indicate the device is executing on the specified device type.
In Fortran, @code{true} is returned. If the program is not executing
on the specified device type C/C++ returns zero, while Fortran
@@ -4672,13 +4672,13 @@ returns @code{false}.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_on_device(acc_device_t devicetype);}
+@item @emph{Prototype}: @tab @code{void acc_on_device(acc_device_t dev_type);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_on_device(devicetype)}
-@item @tab @code{integer(acc_device_kind) devicetype}
+@item @emph{Interface}: @tab @code{function acc_on_device(dev_type)}
+@item @tab @code{integer(acc_device_kind) dev_type}
@item @tab @code{logical acc_on_device}
@end multitable
@@ -4744,34 +4744,34 @@ Free previously allocated device memory at the device address @code{data_dev}.
@section @code{acc_copyin} -- Allocate device memory and copy host memory to it.
@table @asis
@item @emph{Description}
-In C/C++, this function allocates @var{len} bytes of device memory
-and maps it to the specified host address in @var{a}. The device
+In C/C++, this function allocates @var{bytes} bytes of device memory
+and maps it to the specified host address in @var{data_arg}. The device
address of the newly allocated device memory is returned.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a
-variable or array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a
+variable or array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void *acc_copyin(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_copyin_async(h_void *data_arg, size_t bytes, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_copyin(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyin_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -4785,36 +4785,36 @@ variable or array element and @var{len} specifies the length in bytes.
@section @code{acc_present_or_copyin} -- If the data is not present on the device, allocate device memory and copy from host memory.
@table @asis
@item @emph{Description}
-This function tests if the host data specified by @var{a} and of length
-@var{len} is present or not. If it is not present, device memory
+This function tests if the host data specified by @var{data_arg} and of length
+@var{bytes} is present or not. If it is not present, device memory
is allocated and the host memory copied. The device address of
the newly allocated device memory is returned.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
Note that @code{acc_present_or_copyin} and @code{acc_pcopyin} exist for
backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *a, size_t len);}
+@item @emph{Prototype}: @tab @code{void *acc_present_or_copyin(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_pcopyin(h_void *data_arg, size_t bytes);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_copyin(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_pcopyin(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
@end multitable
@item @emph{Reference}:
@@ -4829,33 +4829,33 @@ backward compatibility with OpenACC 2.0; use @ref{acc_copyin} instead.
@table @asis
@item @emph{Description}
This function allocates device memory and maps it to host memory specified
-by the host address @var{a} with a length of @var{len} bytes. In C/C++,
+by the host address @var{data_arg} with a length of @var{bytes} bytes. In C/C++,
the function returns the device address of the allocated device memory.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_create(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void *acc_create(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void *acc_create_async(h_void *data_arg, size_t bytes, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_create(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_create(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_create_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_create(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_create_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -4869,36 +4869,36 @@ array element and @var{len} specifies the length in bytes.
@section @code{acc_present_or_create} -- If the data is not present on the device, allocate device memory and map it to host memory.
@table @asis
@item @emph{Description}
-This function tests if the host data specified by @var{a} and of length
-@var{len} is present or not. If it is not present, device memory
+This function tests if the host data specified by @var{data_args} and of length
+@var{bytes} is present or not. If it is not present, device memory
is allocated and mapped to host memory. In C/C++, the device address
of the newly allocated device memory is returned.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_args} specifies
+a contiguous array section. The second form @var{data_args} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
Note that @code{acc_present_or_create} and @code{acc_pcreate} exist for
backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *a, size_t len)}
-@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *a, size_t len)}
+@item @emph{Prototype}: @tab @code{void *acc_present_or_create(h_void *data_args, size_t bytes)}
+@item @emph{Prototype}: @tab @code{void *acc_pcreate(h_void *data_args, size_t bytes)}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_pcreate(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args)}
+@item @tab @code{type(*), dimension(..) :: data_args}
+@item @emph{Interface}: @tab @code{subroutine acc_present_or_create(data_args, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_args}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args)}
+@item @tab @code{type(*), dimension(..) :: data_args}
+@item @emph{Interface}: @tab @code{subroutine acc_pcreate(data_args, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_args}
+@item @tab @code{integer bytes}
@end multitable
@item @emph{Reference}:
@@ -4913,46 +4913,46 @@ backward compatibility with OpenACC 2.0; use @ref{acc_create} instead.
@table @asis
@item @emph{Description}
This function copies mapped device memory to host memory which is specified
-by host address @var{a} for a length @var{len} bytes in C/C++.
+by host address @var{data_arg} for a length @var{bytes} bytes in C/C++.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_copyout(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_copyout_async(h_void *a, size_t len, int async);}
-@item @emph{Prototype}: @tab @code{acc_copyout_finalize(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_copyout_finalize_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{void acc_copyout(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_async(h_void *data_arg, size_t bytes, int async_arg);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_finalize(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_copyout_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_copyout(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_copyout_finalize_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -4967,46 +4967,46 @@ array element and @var{len} specifies the length in bytes.
@table @asis
@item @emph{Description}
This function frees previously allocated device memory specified by
-the device address @var{a} and the length of @var{len} bytes.
+the device address @var{data_arg} and the length of @var{bytes} bytes.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_delete(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *a, size_t len, int async);}
-@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{acc_delete(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_delete_async(h_void *data_arg, size_t bytes, int async_arg);}
+@item @emph{Prototype}: @tab @code{acc_delete_finalize(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_delete_finalize_async(h_void *data_arg, size_t bytes, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_delete(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_delete(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_finalize(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_delete_async_finalize(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -5021,33 +5021,33 @@ array element and @var{len} specifies the length in bytes.
@table @asis
@item @emph{Description}
This function updates the device copy from the previously mapped host memory.
-The host memory is specified with the host address @var{a} and a length of
-@var{len} bytes.
+The host memory is specified with the host address @var{data_arg} and a length of
+@var{bytes} bytes.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_update_device(h_void *a, size_t len, async);}
+@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{void acc_update_device(h_void *data_arg, size_t bytes, async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_update_device(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_device_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -5062,33 +5062,33 @@ array element and @var{len} specifies the length in bytes.
@table @asis
@item @emph{Description}
This function updates the host copy from the previously mapped device memory.
-The host memory is specified with the host address @var{a} and a length of
-@var{len} bytes.
+The host memory is specified with the host address @var{data_arg} and a length of
+@var{bytes} bytes.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes.
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{acc_update_self(h_void *a, size_t len);}
-@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *a, size_t len, int async);}
+@item @emph{Prototype}: @tab @code{acc_update_self(h_void *data_arg, size_t bytes);}
+@item @emph{Prototype}: @tab @code{acc_update_self_async(h_void *data_arg, size_t bytes, int async_arg);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{subroutine acc_update_self(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer(acc_handle_kind) :: async}
-@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(a, len, async)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
-@item @tab @code{integer(acc_handle_kind) :: async}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
+@item @emph{Interface}: @tab @code{subroutine acc_update_self_async(data_arg, bytes, async_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
+@item @tab @code{integer(acc_handle_kind) :: async_arg}
@end multitable
@item @emph{Reference}:
@@ -5209,31 +5209,31 @@ device address specified by @var{data_dev}.
@section @code{acc_is_present} -- Indicate whether host variable / array is present on device.
@table @asis
@item @emph{Description}
-This function indicates whether the specified host address in @var{a} and a
-length of @var{len} bytes is present on the device. In C/C++, a non-zero
+This function indicates whether the specified host address in @var{data_arg} and a
+length of @var{bytes} bytes is present on the device. In C/C++, a non-zero
value is returned to indicate the presence of the mapped memory on the
device. A zero is returned to indicate the memory is not mapped on the
device.
-In Fortran, two (2) forms are supported. In the first form, @var{a} specifies
-a contiguous array section. The second form @var{a} specifies a variable or
-array element and @var{len} specifies the length in bytes. If the host
+In Fortran, two (2) forms are supported. In the first form, @var{data_arg} specifies
+a contiguous array section. The second form @var{data_arg} specifies a variable or
+array element and @var{bytes} specifies the length in bytes. If the host
memory is mapped to device memory, then a @code{true} is returned. Otherwise,
a @code{false} is return to indicate the mapped memory is not present.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
-@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *a, size_t len);}
+@item @emph{Prototype}: @tab @code{int acc_is_present(h_void *data_arg, size_t bytes);}
@end multitable
@item @emph{Fortran}:
@multitable @columnfractions .20 .80
-@item @emph{Interface}: @tab @code{function acc_is_present(a)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
+@item @emph{Interface}: @tab @code{function acc_is_present(data_arg)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
@item @tab @code{logical acc_is_present}
-@item @emph{Interface}: @tab @code{function acc_is_present(a, len)}
-@item @tab @code{type, dimension(:[,:]...) :: a}
-@item @tab @code{integer len}
+@item @emph{Interface}: @tab @code{function acc_is_present(data_arg, bytes)}
+@item @tab @code{type(*), dimension(..) :: data_arg}
+@item @tab @code{integer bytes}
@item @tab @code{logical acc_is_present}
@end multitable
@@ -5326,7 +5326,7 @@ address to pointing to the corresponding device data.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
@item @emph{Prototype}: @tab @code{void acc_attach(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_attach_async(h_void **ptr_addr, int async_arg);}
@end multitable
@c @item @emph{Fortran}:
@@ -5356,9 +5356,9 @@ address to pointing to the corresponding host data.
@item @emph{C/C++}:
@multitable @columnfractions .20 .80
@item @emph{Prototype}: @tab @code{void acc_detach(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_detach_async(h_void **ptr_addr, int async_arg);}
@item @emph{Prototype}: @tab @code{void acc_detach_finalize(h_void **ptr_addr);}
-@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async);}
+@item @emph{Prototype}: @tab @code{void acc_detach_finalize_async(h_void **ptr_addr, int async_arg);}
@end multitable
@c @item @emph{Fortran}:
@@ -74,15 +74,15 @@ module openacc_internal
implicit none
interface
- function acc_get_num_devices_h (devicetype)
+ function acc_get_num_devices_h (dev_type)
import
integer acc_get_num_devices_h
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end function
- subroutine acc_set_device_type_h (devicetype)
+ subroutine acc_set_device_type_h (dev_type)
import
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
function acc_get_device_type_h ()
@@ -90,435 +90,435 @@ module openacc_internal
integer (acc_device_kind) acc_get_device_type_h
end function
- subroutine acc_set_device_num_h (devicenum, devicetype)
+ subroutine acc_set_device_num_h (dev_num, dev_type)
import
- integer devicenum
- integer (acc_device_kind) devicetype
+ integer dev_num
+ integer (acc_device_kind) dev_type
end subroutine
- function acc_get_device_num_h (devicetype)
+ function acc_get_device_num_h (dev_type)
import
integer acc_get_device_num_h
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end function
- function acc_get_property_h (devicenum, devicetype, property)
+ function acc_get_property_h (dev_num, dev_type, property)
use iso_c_binding, only: c_size_t
import
implicit none (type, external)
integer (c_size_t) :: acc_get_property_h
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
end function
- subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
+ subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
import
implicit none (type, external)
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
character (*) :: string
end subroutine
- function acc_async_test_h (arg)
+ function acc_async_test_h (wait_arg)
logical acc_async_test_h
- integer arg
+ integer wait_arg
end function
function acc_async_test_all_h ()
logical acc_async_test_all_h
end function
- subroutine acc_wait_h (arg)
- integer arg
+ subroutine acc_wait_h (wait_arg)
+ integer wait_arg
end subroutine
- subroutine acc_wait_async_h (arg, async)
- integer arg, async
+ subroutine acc_wait_async_h (wait_arg, async_arg)
+ integer wait_arg, async_arg
end subroutine
subroutine acc_wait_all_h ()
end subroutine
- subroutine acc_wait_all_async_h (async)
- integer async
+ subroutine acc_wait_all_async_h (async_arg)
+ integer async_arg
end subroutine
- subroutine acc_init_h (devicetype)
+ subroutine acc_init_h (dev_type)
import
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
- subroutine acc_shutdown_h (devicetype)
+ subroutine acc_shutdown_h (dev_type)
import
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
- function acc_on_device_h (devicetype)
+ function acc_on_device_h (dev_type)
import
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
logical acc_on_device_h
end function
- subroutine acc_copyin_32_h (a, len)
+ subroutine acc_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyin_64_h (a, len)
+ subroutine acc_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyin_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyin_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_present_or_copyin_32_h (a, len)
+ subroutine acc_present_or_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_present_or_copyin_64_h (a, len)
+ subroutine acc_present_or_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_present_or_copyin_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_present_or_copyin_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_create_32_h (a, len)
+ subroutine acc_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_create_64_h (a, len)
+ subroutine acc_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_create_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_create_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_present_or_create_32_h (a, len)
+ subroutine acc_present_or_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_present_or_create_64_h (a, len)
+ subroutine acc_present_or_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_present_or_create_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_present_or_create_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_copyout_32_h (a, len)
+ subroutine acc_copyout_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyout_64_h (a, len)
+ subroutine acc_copyout_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyout_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyout_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_copyout_finalize_32_h (a, len)
+ subroutine acc_copyout_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyout_finalize_64_h (a, len)
+ subroutine acc_copyout_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyout_finalize_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyout_finalize_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_delete_32_h (a, len)
+ subroutine acc_delete_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_delete_64_h (a, len)
+ subroutine acc_delete_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_delete_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_delete_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_delete_finalize_32_h (a, len)
+ subroutine acc_delete_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_delete_finalize_64_h (a, len)
+ subroutine acc_delete_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_delete_finalize_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_delete_finalize_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_update_device_32_h (a, len)
+ subroutine acc_update_device_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_update_device_64_h (a, len)
+ subroutine acc_update_device_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_update_device_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_update_device_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- subroutine acc_update_self_32_h (a, len)
+ subroutine acc_update_self_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_update_self_64_h (a, len)
+ subroutine acc_update_self_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_update_self_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_update_self_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
- function acc_is_present_32_h (a, len)
+ function acc_is_present_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
logical acc_is_present_32_h
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end function
- function acc_is_present_64_h (a, len)
+ function acc_is_present_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
logical acc_is_present_64_h
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end function
- function acc_is_present_array_h (a)
+ function acc_is_present_array_h (data_arg)
logical acc_is_present_array_h
- type (*), dimension (..), contiguous :: a
+ type (*), dimension (..), contiguous :: data_arg
end function
- subroutine acc_copyin_async_32_h (a, len, async)
+ subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyin_async_64_h (a, len, async)
+ subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyin_async_array_h (a, async)
+ subroutine acc_copyin_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_create_async_32_h (a, len, async)
+ subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_create_async_64_h (a, len, async)
+ subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_create_async_array_h (a, async)
+ subroutine acc_create_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyout_async_32_h (a, len, async)
+ subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyout_async_64_h (a, len, async)
+ subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyout_async_array_h (a, async)
+ subroutine acc_copyout_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_delete_async_32_h (a, len, async)
+ subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_delete_async_64_h (a, len, async)
+ subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_delete_async_array_h (a, async)
+ subroutine acc_delete_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_device_async_32_h (a, len, async)
+ subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_device_async_64_h (a, len, async)
+ subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_device_async_array_h (a, async)
+ subroutine acc_update_device_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_self_async_32_h (a, len, async)
+ subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_self_async_64_h (a, len, async)
+ subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_self_async_array_h (a, async)
+ subroutine acc_update_self_async_array_h (data_arg, async_arg)
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface
- function acc_get_num_devices_l (devicetype) &
+ function acc_get_num_devices_l (dev_type) &
bind (C, name = "acc_get_num_devices")
use iso_c_binding, only: c_int
integer (c_int) :: acc_get_num_devices_l
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end function
- subroutine acc_set_device_type_l (devicetype) &
+ subroutine acc_set_device_type_l (dev_type) &
bind (C, name = "acc_set_device_type")
use iso_c_binding, only: c_int
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end subroutine
function acc_get_device_type_l () &
@@ -527,44 +527,44 @@ module openacc_internal
integer (c_int) :: acc_get_device_type_l
end function
- subroutine acc_set_device_num_l (devicenum, devicetype) &
+ subroutine acc_set_device_num_l (dev_num, dev_type) &
bind (C, name = "acc_set_device_num")
use iso_c_binding, only: c_int
- integer (c_int), value :: devicenum, devicetype
+ integer (c_int), value :: dev_num, dev_type
end subroutine
- function acc_get_device_num_l (devicetype) &
+ function acc_get_device_num_l (dev_type) &
bind (C, name = "acc_get_device_num")
use iso_c_binding, only: c_int
integer (c_int) :: acc_get_device_num_l
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end function
- function acc_get_property_l (devicenum, devicetype, property) &
+ function acc_get_property_l (dev_num, dev_type, property) &
bind (C, name = "acc_get_property")
use iso_c_binding, only: c_int, c_size_t
implicit none (type, external)
integer (c_size_t) :: acc_get_property_l
- integer (c_int), value :: devicenum
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_num
+ integer (c_int), value :: dev_type
integer (c_int), value :: property
end function
- function acc_get_property_string_l (devicenum, devicetype, property) &
+ function acc_get_property_string_l (dev_num, dev_type, property) &
bind (C, name = "acc_get_property_string")
use iso_c_binding, only: c_int, c_ptr
implicit none (type, external)
type (c_ptr) :: acc_get_property_string_l
- integer (c_int), value :: devicenum
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_num
+ integer (c_int), value :: dev_type
integer (c_int), value :: property
end function
- function acc_async_test_l (a) &
+ function acc_async_test_l (data_arg) &
bind (C, name = "acc_async_test")
use iso_c_binding, only: c_int
integer (c_int) :: acc_async_test_l
- integer (c_int), value :: a
+ integer (c_int), value :: data_arg
end function
function acc_async_test_all_l () &
@@ -573,16 +573,16 @@ module openacc_internal
integer (c_int) :: acc_async_test_all_l
end function
- subroutine acc_wait_l (a) &
+ subroutine acc_wait_l (data_arg) &
bind (C, name = "acc_wait")
use iso_c_binding, only: c_int
- integer (c_int), value :: a
+ integer (c_int), value :: data_arg
end subroutine
- subroutine acc_wait_async_l (arg, async) &
+ subroutine acc_wait_async_l (wait_arg, async_arg) &
bind (C, name = "acc_wait_async")
use iso_c_binding, only: c_int
- integer (c_int), value :: arg, async
+ integer (c_int), value :: wait_arg, async_arg
end subroutine
subroutine acc_wait_all_l () &
@@ -590,172 +590,172 @@ module openacc_internal
use iso_c_binding, only: c_int
end subroutine
- subroutine acc_wait_all_async_l (async) &
+ subroutine acc_wait_all_async_l (async_arg) &
bind (C, name = "acc_wait_all_async")
use iso_c_binding, only: c_int
- integer (c_int), value :: async
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_init_l (devicetype) &
+ subroutine acc_init_l (dev_type) &
bind (C, name = "acc_init")
use iso_c_binding, only: c_int
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end subroutine
- subroutine acc_shutdown_l (devicetype) &
+ subroutine acc_shutdown_l (dev_type) &
bind (C, name = "acc_shutdown")
use iso_c_binding, only: c_int
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end subroutine
- function acc_on_device_l (devicetype) &
+ function acc_on_device_l (dev_type) &
bind (C, name = "acc_on_device")
use iso_c_binding, only: c_int
integer (c_int) :: acc_on_device_l
- integer (c_int), value :: devicetype
+ integer (c_int), value :: dev_type
end function
- subroutine acc_copyin_l (a, len) &
+ subroutine acc_copyin_l (data_arg, bytes) &
bind (C, name = "acc_copyin")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_present_or_copyin_l (a, len) &
+ subroutine acc_present_or_copyin_l (data_arg, bytes) &
bind (C, name = "acc_present_or_copyin")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_create_l (a, len) &
+ subroutine acc_create_l (data_arg, bytes) &
bind (C, name = "acc_create")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_present_or_create_l (a, len) &
+ subroutine acc_present_or_create_l (data_arg, bytes) &
bind (C, name = "acc_present_or_create")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_copyout_l (a, len) &
+ subroutine acc_copyout_l (data_arg, bytes) &
bind (C, name = "acc_copyout")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_copyout_finalize_l (a, len) &
+ subroutine acc_copyout_finalize_l (data_arg, bytes) &
bind (C, name = "acc_copyout_finalize")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_delete_l (a, len) &
+ subroutine acc_delete_l (data_arg, bytes) &
bind (C, name = "acc_delete")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_delete_finalize_l (a, len) &
+ subroutine acc_delete_finalize_l (data_arg, bytes) &
bind (C, name = "acc_delete_finalize")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_update_device_l (a, len) &
+ subroutine acc_update_device_l (data_arg, bytes) &
bind (C, name = "acc_update_device")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- subroutine acc_update_self_l (a, len) &
+ subroutine acc_update_self_l (data_arg, bytes) &
bind (C, name = "acc_update_self")
use iso_c_binding, only: c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end subroutine
- function acc_is_present_l (a, len) &
+ function acc_is_present_l (data_arg, bytes) &
bind (C, name = "acc_is_present")
use iso_c_binding, only: c_int32_t, c_size_t
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
integer (c_int32_t) :: acc_is_present_l
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
end function
- subroutine acc_copyin_async_l (a, len, async) &
+ subroutine acc_copyin_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_copyin_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_create_async_l (a, len, async) &
+ subroutine acc_create_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_create_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_copyout_async_l (a, len, async) &
+ subroutine acc_copyout_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_copyout_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_delete_async_l (a, len, async) &
+ subroutine acc_delete_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_delete_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_update_device_async_l (a, len, async) &
+ subroutine acc_update_device_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_update_device_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
- subroutine acc_update_self_async_l (a, len, async) &
+ subroutine acc_update_self_async_l (data_arg, bytes, async_arg) &
bind (C, name = "acc_update_self_async")
use iso_c_binding, only: c_size_t, c_int
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_size_t), value :: len
- integer (c_int), value :: async
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_size_t), value :: bytes
+ integer (c_int), value :: async_arg
end subroutine
end interface
end module openacc_internal
@@ -1084,19 +1084,19 @@ module openacc
end module openacc
-function acc_get_num_devices_h (devicetype)
+function acc_get_num_devices_h (dev_type)
use openacc_internal, only: acc_get_num_devices_l
use openacc_kinds
integer acc_get_num_devices_h
- integer (acc_device_kind) devicetype
- acc_get_num_devices_h = acc_get_num_devices_l (devicetype)
+ integer (acc_device_kind) dev_type
+ acc_get_num_devices_h = acc_get_num_devices_l (dev_type)
end function
-subroutine acc_set_device_type_h (devicetype)
+subroutine acc_set_device_type_h (dev_type)
use openacc_internal, only: acc_set_device_type_l
use openacc_kinds
- integer (acc_device_kind) devicetype
- call acc_set_device_type_l (devicetype)
+ integer (acc_device_kind) dev_type
+ call acc_set_device_type_l (dev_type)
end subroutine
function acc_get_device_type_h ()
@@ -1106,41 +1106,41 @@ function acc_get_device_type_h ()
acc_get_device_type_h = acc_get_device_type_l ()
end function
-subroutine acc_set_device_num_h (devicenum, devicetype)
+subroutine acc_set_device_num_h (dev_num, dev_type)
use openacc_internal, only: acc_set_device_num_l
use openacc_kinds
- integer devicenum
- integer (acc_device_kind) devicetype
- call acc_set_device_num_l (devicenum, devicetype)
+ integer dev_num
+ integer (acc_device_kind) dev_type
+ call acc_set_device_num_l (dev_num, dev_type)
end subroutine
-function acc_get_device_num_h (devicetype)
+function acc_get_device_num_h (dev_type)
use openacc_internal, only: acc_get_device_num_l
use openacc_kinds
integer acc_get_device_num_h
- integer (acc_device_kind) devicetype
- acc_get_device_num_h = acc_get_device_num_l (devicetype)
+ integer (acc_device_kind) dev_type
+ acc_get_device_num_h = acc_get_device_num_l (dev_type)
end function
-function acc_get_property_h (devicenum, devicetype, property)
+function acc_get_property_h (dev_num, dev_type, property)
use iso_c_binding, only: c_size_t
use openacc_internal, only: acc_get_property_l
use openacc_kinds
implicit none (type, external)
integer (c_size_t) :: acc_get_property_h
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
- acc_get_property_h = acc_get_property_l (devicenum, devicetype, property)
+ acc_get_property_h = acc_get_property_l (dev_num, dev_type, property)
end function
-subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
+subroutine acc_get_property_string_h (dev_num, dev_type, property, string)
use iso_c_binding, only: c_char, c_size_t, c_ptr, c_f_pointer, c_associated
use openacc_internal, only: acc_get_property_string_l
use openacc_kinds
implicit none (type, external)
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
character (*) :: string
@@ -1156,7 +1156,7 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
end function strlen
end interface
- cptr = acc_get_property_string_l (devicenum, devicetype, property)
+ cptr = acc_get_property_string_l (dev_num, dev_type, property)
string = ""
if (.not. c_associated (cptr)) then
return
@@ -1171,11 +1171,11 @@ subroutine acc_get_property_string_h (devicenum, devicetype, property, string)
end do
end subroutine
-function acc_async_test_h (arg)
+function acc_async_test_h (wait_arg)
use openacc_internal, only: acc_async_test_l
logical acc_async_test_h
- integer arg
- acc_async_test_h = acc_async_test_l (arg) /= 0
+ integer wait_arg
+ acc_async_test_h = acc_async_test_l (wait_arg) /= 0
end function
function acc_async_test_all_h ()
@@ -1184,16 +1184,16 @@ function acc_async_test_all_h ()
acc_async_test_all_h = acc_async_test_all_l () /= 0
end function
-subroutine acc_wait_h (arg)
+subroutine acc_wait_h (wait_arg)
use openacc_internal, only: acc_wait_l
- integer arg
- call acc_wait_l (arg)
+ integer wait_arg
+ call acc_wait_l (wait_arg)
end subroutine
-subroutine acc_wait_async_h (arg, async)
+subroutine acc_wait_async_h (wait_arg, async_arg)
use openacc_internal, only: acc_wait_async_l
- integer arg, async
- call acc_wait_async_l (arg, async)
+ integer wait_arg, async_arg
+ call acc_wait_async_l (wait_arg, async_arg)
end subroutine
subroutine acc_wait_all_h ()
@@ -1201,483 +1201,483 @@ subroutine acc_wait_all_h ()
call acc_wait_all_l ()
end subroutine
-subroutine acc_wait_all_async_h (async)
+subroutine acc_wait_all_async_h (async_arg)
use openacc_internal, only: acc_wait_all_async_l
- integer async
- call acc_wait_all_async_l (async)
+ integer async_arg
+ call acc_wait_all_async_l (async_arg)
end subroutine
-subroutine acc_init_h (devicetype)
+subroutine acc_init_h (dev_type)
use openacc_internal, only: acc_init_l
use openacc_kinds
- integer (acc_device_kind) devicetype
- call acc_init_l (devicetype)
+ integer (acc_device_kind) dev_type
+ call acc_init_l (dev_type)
end subroutine
-subroutine acc_shutdown_h (devicetype)
+subroutine acc_shutdown_h (dev_type)
use openacc_internal, only: acc_shutdown_l
use openacc_kinds
- integer (acc_device_kind) devicetype
- call acc_shutdown_l (devicetype)
+ integer (acc_device_kind) dev_type
+ call acc_shutdown_l (dev_type)
end subroutine
-function acc_on_device_h (devicetype)
+function acc_on_device_h (dev_type)
use openacc_internal, only: acc_on_device_l
use openacc_kinds
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
logical acc_on_device_h
- acc_on_device_h = acc_on_device_l (devicetype) /= 0
+ acc_on_device_h = acc_on_device_l (dev_type) /= 0
end function
-subroutine acc_copyin_32_h (a, len)
+subroutine acc_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_copyin_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_copyin_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyin_64_h (a, len)
+subroutine acc_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_copyin_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_copyin_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_copyin_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyin_array_h (a)
+subroutine acc_copyin_array_h (data_arg)
use openacc_internal, only: acc_copyin_l
- type (*), dimension (..), contiguous :: a
- call acc_copyin_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_copyin_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_present_or_copyin_32_h (a, len)
+subroutine acc_present_or_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_present_or_copyin_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_present_or_copyin_64_h (a, len)
+subroutine acc_present_or_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_present_or_copyin_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_present_or_copyin_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_present_or_copyin_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_present_or_copyin_array_h (a)
+subroutine acc_present_or_copyin_array_h (data_arg)
use openacc_internal, only: acc_present_or_copyin_l
- type (*), dimension (..), contiguous :: a
- call acc_present_or_copyin_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_present_or_copyin_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_create_32_h (a, len)
+subroutine acc_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_create_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_create_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_create_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_create_64_h (a, len)
+subroutine acc_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_create_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_create_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_create_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_create_array_h (a)
+subroutine acc_create_array_h (data_arg)
use openacc_internal, only: acc_create_l
- type (*), dimension (..), contiguous :: a
- call acc_create_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_create_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_present_or_create_32_h (a, len)
+subroutine acc_present_or_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_present_or_create_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_present_or_create_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_present_or_create_64_h (a, len)
+subroutine acc_present_or_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_present_or_create_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_present_or_create_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_present_or_create_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_present_or_create_array_h (a)
+subroutine acc_present_or_create_array_h (data_arg)
use openacc_internal, only: acc_present_or_create_l
- type (*), dimension (..), contiguous :: a
- call acc_present_or_create_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_present_or_create_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_copyout_32_h (a, len)
+subroutine acc_copyout_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_copyout_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_copyout_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyout_64_h (a, len)
+subroutine acc_copyout_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_copyout_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_copyout_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_copyout_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyout_array_h (a)
+subroutine acc_copyout_array_h (data_arg)
use openacc_internal, only: acc_copyout_l
- type (*), dimension (..), contiguous :: a
- call acc_copyout_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_copyout_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_copyout_finalize_32_h (a, len)
+subroutine acc_copyout_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_copyout_finalize_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyout_finalize_64_h (a, len)
+subroutine acc_copyout_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_copyout_finalize_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_copyout_finalize_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_copyout_finalize_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_copyout_finalize_array_h (a)
+subroutine acc_copyout_finalize_array_h (data_arg)
use openacc_internal, only: acc_copyout_finalize_l
- type (*), dimension (..), contiguous :: a
- call acc_copyout_finalize_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_copyout_finalize_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_delete_32_h (a, len)
+subroutine acc_delete_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_delete_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_delete_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_delete_64_h (a, len)
+subroutine acc_delete_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_delete_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_delete_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_delete_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_delete_array_h (a)
+subroutine acc_delete_array_h (data_arg)
use openacc_internal, only: acc_delete_l
- type (*), dimension (..), contiguous :: a
- call acc_delete_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_delete_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_delete_finalize_32_h (a, len)
+subroutine acc_delete_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_delete_finalize_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_delete_finalize_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_delete_finalize_64_h (a, len)
+subroutine acc_delete_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_delete_finalize_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_delete_finalize_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_delete_finalize_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_delete_finalize_array_h (a)
+subroutine acc_delete_finalize_array_h (data_arg)
use openacc_internal, only: acc_delete_finalize_l
- type (*), dimension (..), contiguous :: a
- call acc_delete_finalize_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_delete_finalize_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_update_device_32_h (a, len)
+subroutine acc_update_device_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_update_device_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_update_device_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_update_device_64_h (a, len)
+subroutine acc_update_device_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_update_device_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_update_device_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_update_device_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_update_device_array_h (a)
+subroutine acc_update_device_array_h (data_arg)
use openacc_internal, only: acc_update_device_l
- type (*), dimension (..), contiguous :: a
- call acc_update_device_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_update_device_l (data_arg, sizeof (data_arg))
end subroutine
-subroutine acc_update_self_32_h (a, len)
+subroutine acc_update_self_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_update_self_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- call acc_update_self_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_update_self_64_h (a, len)
+subroutine acc_update_self_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_update_self_l
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- call acc_update_self_l (a, int (len, kind = c_size_t))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ call acc_update_self_l (data_arg, int (bytes, kind = c_size_t))
end subroutine
-subroutine acc_update_self_array_h (a)
+subroutine acc_update_self_array_h (data_arg)
use openacc_internal, only: acc_update_self_l
- type (*), dimension (..), contiguous :: a
- call acc_update_self_l (a, sizeof (a))
+ type (*), dimension (..), contiguous :: data_arg
+ call acc_update_self_l (data_arg, sizeof (data_arg))
end subroutine
-function acc_is_present_32_h (a, len)
+function acc_is_present_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t, c_size_t
use openacc_internal, only: acc_is_present_l
logical acc_is_present_32_h
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- acc_is_present_32_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ acc_is_present_32_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
end function
-function acc_is_present_64_h (a, len)
+function acc_is_present_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t, c_size_t
use openacc_internal, only: acc_is_present_l
logical acc_is_present_64_h
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- acc_is_present_64_h = acc_is_present_l (a, int (len, kind = c_size_t)) /= 0
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ acc_is_present_64_h = acc_is_present_l (data_arg, int (bytes, kind = c_size_t)) /= 0
end function
-function acc_is_present_array_h (a)
+function acc_is_present_array_h (data_arg)
use openacc_internal, only: acc_is_present_l
logical acc_is_present_array_h
- type (*), dimension (..), contiguous :: a
- acc_is_present_array_h = acc_is_present_l (a, sizeof (a)) /= 0
+ type (*), dimension (..), contiguous :: data_arg
+ acc_is_present_array_h = acc_is_present_l (data_arg, sizeof (data_arg)) /= 0
end function
-subroutine acc_copyin_async_32_h (a, len, async)
+subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_copyin_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_copyin_async_64_h (a, len, async)
+subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_copyin_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_copyin_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_copyin_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_copyin_async_array_h (a, async)
+subroutine acc_copyin_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_copyin_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_copyin_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_copyin_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_create_async_32_h (a, len, async)
+subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_create_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_create_async_64_h (a, len, async)
+subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_create_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_create_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_create_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_create_async_array_h (a, async)
+subroutine acc_create_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_create_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_create_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_create_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_copyout_async_32_h (a, len, async)
+subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_copyout_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_copyout_async_64_h (a, len, async)
+subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_copyout_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_copyout_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_copyout_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_copyout_async_array_h (a, async)
+subroutine acc_copyout_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_copyout_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_copyout_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_copyout_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_delete_async_32_h (a, len, async)
+subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_delete_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_delete_async_64_h (a, len, async)
+subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_delete_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_delete_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_delete_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_delete_async_array_h (a, async)
+subroutine acc_delete_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_delete_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_delete_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_delete_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_device_async_32_h (a, len, async)
+subroutine acc_update_device_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_update_device_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_device_async_64_h (a, len, async)
+subroutine acc_update_device_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_update_device_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_update_device_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_update_device_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_device_async_array_h (a, async)
+subroutine acc_update_device_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_update_device_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_update_device_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_update_device_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_self_async_32_h (a, len, async)
+subroutine acc_update_self_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t, c_size_t, c_int
use openacc_internal, only: acc_update_self_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
- call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_self_async_64_h (a, len, async)
+subroutine acc_update_self_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t, c_size_t, c_int
use openacc_internal, only: acc_update_self_async_l
use openacc_kinds, only: acc_handle_kind
- !GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
- call acc_update_self_async_l (a, int (len, kind = c_size_t), int (async, kind = c_int))
+ !GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
+ call acc_update_self_async_l (data_arg, int (bytes, kind = c_size_t), int (async_arg, kind = c_int))
end subroutine
-subroutine acc_update_self_async_array_h (a, async)
+subroutine acc_update_self_async_array_h (data_arg, async_arg)
use iso_c_binding, only: c_int
use openacc_internal, only: acc_update_self_async_l
use openacc_kinds, only: acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async
- call acc_update_self_async_l (a, sizeof (a), int (async, kind = c_int))
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
+ call acc_update_self_async_l (data_arg, sizeof (data_arg), int (async_arg, kind = c_int))
end subroutine
@@ -73,17 +73,17 @@
integer, parameter :: openacc_version = 201711
interface acc_get_num_devices
- function acc_get_num_devices_h (devicetype)
+ function acc_get_num_devices_h (dev_type)
import acc_device_kind
integer acc_get_num_devices_h
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end function
end interface
interface acc_set_device_type
- subroutine acc_set_device_type_h (devicetype)
+ subroutine acc_set_device_type_h (dev_type)
import acc_device_kind
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
end interface
@@ -95,50 +95,50 @@
end interface
interface acc_set_device_num
- subroutine acc_set_device_num_h (devicenum, devicetype)
+ subroutine acc_set_device_num_h (dev_num, dev_type)
import acc_device_kind
- integer devicenum
- integer (acc_device_kind) devicetype
+ integer dev_num
+ integer (acc_device_kind) dev_type
end subroutine
end interface
interface acc_get_device_num
- function acc_get_device_num_h (devicetype)
+ function acc_get_device_num_h (dev_type)
import acc_device_kind
integer acc_get_device_num_h
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end function
end interface
interface acc_get_property
- function acc_get_property_h (devicenum, devicetype, &
+ function acc_get_property_h (dev_num, dev_type, &
& property)
use iso_c_binding, only: c_size_t
import acc_device_kind, acc_device_property_kind
implicit none (type, external)
integer (c_size_t) :: acc_get_property_h
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
end function
end interface
interface acc_get_property_string
- subroutine acc_get_property_string_h (devicenum, devicetype, &
+ subroutine acc_get_property_string_h (dev_num, dev_type, &
& property, string)
import acc_device_kind, acc_device_property_kind
implicit none (type, external)
- integer, value :: devicenum
- integer (acc_device_kind), value :: devicetype
+ integer, value :: dev_num
+ integer (acc_device_kind), value :: dev_type
integer (acc_device_property_kind), value :: property
character (*) :: string
end subroutine
end interface
interface acc_async_test
- function acc_async_test_h (arg)
+ function acc_async_test_h (wait_arg)
logical acc_async_test_h
- integer arg
+ integer wait_arg
end function
end interface
@@ -149,8 +149,8 @@
end interface
interface acc_wait
- subroutine acc_wait_h (arg)
- integer arg
+ subroutine acc_wait_h (wait_arg)
+ integer wait_arg
end subroutine
end interface
@@ -160,8 +160,8 @@
end interface
interface acc_wait_async
- subroutine acc_wait_async_h (arg, async)
- integer arg, async
+ subroutine acc_wait_async_h (wait_arg, async_arg)
+ integer wait_arg, async_arg
end subroutine
end interface
@@ -177,30 +177,30 @@
end interface
interface acc_wait_all_async
- subroutine acc_wait_all_async_h (async)
- integer async
+ subroutine acc_wait_all_async_h (async_arg)
+ integer async_arg
end subroutine
end interface
interface acc_init
- subroutine acc_init_h (devicetype)
+ subroutine acc_init_h (dev_type)
import acc_device_kind
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
end interface
interface acc_shutdown
- subroutine acc_shutdown_h (devicetype)
+ subroutine acc_shutdown_h (dev_type)
import acc_device_kind
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end subroutine
end interface
interface acc_on_device
- function acc_on_device_h (devicetype)
+ function acc_on_device_h (dev_type)
import acc_device_kind
logical acc_on_device_h
- integer (acc_device_kind) devicetype
+ integer (acc_device_kind) dev_type
end function
end interface
@@ -219,42 +219,42 @@
end interface
interface acc_copyin
- subroutine acc_copyin_32_h (a, len)
+ subroutine acc_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyin_64_h (a, len)
+ subroutine acc_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyin_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyin_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_present_or_copyin
- subroutine acc_present_or_copyin_32_h (a, len)
+ subroutine acc_present_or_copyin_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_present_or_copyin_64_h (a, len)
+ subroutine acc_present_or_copyin_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_present_or_copyin_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_present_or_copyin_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
@@ -265,42 +265,42 @@
end interface
interface acc_create
- subroutine acc_create_32_h (a, len)
+ subroutine acc_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_create_64_h (a, len)
+ subroutine acc_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_create_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_create_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_present_or_create
- subroutine acc_present_or_create_32_h (a, len)
+ subroutine acc_present_or_create_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_present_or_create_64_h (a, len)
+ subroutine acc_present_or_create_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_present_or_create_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_present_or_create_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
@@ -311,122 +311,122 @@
end interface
interface acc_copyout
- subroutine acc_copyout_32_h (a, len)
+ subroutine acc_copyout_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyout_64_h (a, len)
+ subroutine acc_copyout_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyout_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyout_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_copyout_finalize
- subroutine acc_copyout_finalize_32_h (a, len)
+ subroutine acc_copyout_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_copyout_finalize_64_h (a, len)
+ subroutine acc_copyout_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_copyout_finalize_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_copyout_finalize_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_delete
- subroutine acc_delete_32_h (a, len)
+ subroutine acc_delete_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_delete_64_h (a, len)
+ subroutine acc_delete_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_delete_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_delete_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_delete_finalize
- subroutine acc_delete_finalize_32_h (a, len)
+ subroutine acc_delete_finalize_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_delete_finalize_64_h (a, len)
+ subroutine acc_delete_finalize_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_delete_finalize_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_delete_finalize_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_update_device
- subroutine acc_update_device_32_h (a, len)
+ subroutine acc_update_device_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_update_device_64_h (a, len)
+ subroutine acc_update_device_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_update_device_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_update_device_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
interface acc_update_self
- subroutine acc_update_self_32_h (a, len)
+ subroutine acc_update_self_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end subroutine
- subroutine acc_update_self_64_h (a, len)
+ subroutine acc_update_self_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end subroutine
- subroutine acc_update_self_array_h (a)
- type (*), dimension (..), contiguous :: a
+ subroutine acc_update_self_array_h (data_arg)
+ type (*), dimension (..), contiguous :: data_arg
end subroutine
end interface
@@ -460,25 +460,25 @@
end interface
interface acc_is_present
- function acc_is_present_32_h (a, len)
+ function acc_is_present_32_h (data_arg, bytes)
use iso_c_binding, only: c_int32_t
logical acc_is_present_32_h
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
end function
- function acc_is_present_64_h (a, len)
+ function acc_is_present_64_h (data_arg, bytes)
use iso_c_binding, only: c_int64_t
logical acc_is_present_64_h
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
end function
- function acc_is_present_array_h (a)
+ function acc_is_present_array_h (data_arg)
logical acc_is_present_array_h
- type (*), dimension (..), contiguous :: a
+ type (*), dimension (..), contiguous :: data_arg
end function
end interface
@@ -529,157 +529,161 @@
end interface
interface acc_copyin_async
- subroutine acc_copyin_async_32_h (a, len, async)
+ subroutine acc_copyin_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyin_async_64_h (a, len, async)
+ subroutine acc_copyin_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyin_async_array_h (a, async_)
+ subroutine acc_copyin_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface acc_create_async
- subroutine acc_create_async_32_h (a, len, async)
+ subroutine acc_create_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_create_async_64_h (a, len, async)
+ subroutine acc_create_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_create_async_array_h (a, async_)
+ subroutine acc_create_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface acc_copyout_async
- subroutine acc_copyout_async_32_h (a, len, async)
+ subroutine acc_copyout_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyout_async_64_h (a, len, async)
+ subroutine acc_copyout_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_copyout_async_array_h (a, async_)
+ subroutine acc_copyout_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface acc_delete_async
- subroutine acc_delete_async_32_h (a, len, async)
+ subroutine acc_delete_async_32_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_delete_async_64_h (a, len, async)
+ subroutine acc_delete_async_64_h (data_arg, bytes, async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_delete_async_array_h (a, async_)
+ subroutine acc_delete_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface acc_update_device_async
- subroutine acc_update_device_async_32_h (a, len, async)
+ subroutine acc_update_device_async_32_h (data_arg, bytes, &
+ & async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_device_async_64_h (a, len, async)
+ subroutine acc_update_device_async_64_h (data_arg, bytes, &
+ & async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_device_async_array_h (a, async_)
+ subroutine acc_update_device_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface
interface acc_update_self_async
- subroutine acc_update_self_async_32_h (a, len, async)
+ subroutine acc_update_self_async_32_h (data_arg, bytes, &
+ & async_arg)
use iso_c_binding, only: c_int32_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int32_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int32_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_self_async_64_h (a, len, async)
+ subroutine acc_update_self_async_64_h (data_arg, bytes, &
+ & async_arg)
use iso_c_binding, only: c_int64_t
import acc_handle_kind
-!GCC$ ATTRIBUTES NO_ARG_CHECK :: a
- type (*), dimension (*) :: a
- integer (c_int64_t) len
- integer (acc_handle_kind) async
+!GCC$ ATTRIBUTES NO_ARG_CHECK :: data_arg
+ type (*), dimension (*) :: data_arg
+ integer (c_int64_t) bytes
+ integer (acc_handle_kind) async_arg
end subroutine
- subroutine acc_update_self_async_array_h (a, async_)
+ subroutine acc_update_self_async_array_h (data_arg, async_arg)
import acc_handle_kind
- type (*), dimension (..), contiguous :: a
- integer (acc_handle_kind) async_
+ type (*), dimension (..), contiguous :: data_arg
+ integer (acc_handle_kind) async_arg
end subroutine
end interface