From patchwork Tue Feb 27 19:11:30 2024 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Tobias Burnus X-Patchwork-Id: 86475 Return-Path: X-Original-To: patchwork@sourceware.org Delivered-To: patchwork@sourceware.org Received: from server2.sourceware.org (localhost [IPv6:::1]) by sourceware.org (Postfix) with ESMTP id 311113858C24 for ; Tue, 27 Feb 2024 19:12:13 +0000 (GMT) X-Original-To: gcc-patches@gcc.gnu.org Delivered-To: gcc-patches@gcc.gnu.org Received: from mail-ed1-x531.google.com (mail-ed1-x531.google.com [IPv6:2a00:1450:4864:20::531]) by sourceware.org (Postfix) with ESMTPS id 96D403858D20 for ; Tue, 27 Feb 2024 19:11:33 +0000 (GMT) DMARC-Filter: OpenDMARC Filter v1.4.2 sourceware.org 96D403858D20 Authentication-Results: sourceware.org; dmarc=none (p=none dis=none) header.from=baylibre.com Authentication-Results: sourceware.org; spf=pass smtp.mailfrom=baylibre.com ARC-Filter: OpenARC Filter v1.0.0 sourceware.org 96D403858D20 Authentication-Results: server2.sourceware.org; arc=none smtp.remote-ip=2a00:1450:4864:20::531 ARC-Seal: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709061101; cv=none; b=T/oRPOzvlEOdfNpHBR5/fuPjWiIiL+Rl6lzHJd/6mx1CSYDvVmQjeKHSVDq0I0bFRHgUtjIAnUt9mMFuxGf5TFaxM0pUILcmruUN41vnjsHWat7drlCFjQbaPXbb/6q0npY1XRZsE/2bwr1873lJp6Zcf5DnRgXZdG2doa3JzBM= ARC-Message-Signature: i=1; a=rsa-sha256; d=sourceware.org; s=key; t=1709061101; c=relaxed/simple; bh=FF+hk4JKOtKVy0nMH6rQR0iyGMckMxB4kQVblcaTe44=; h=DKIM-Signature:Message-ID:Date:MIME-Version:To:From:Subject; b=ZAKkvJ2A0z1dxdaPGzdupKhvt1drm3Jby0Umd9gvhaGAJDOwKxOMAMakn8Pa62wfbgL5EHYnyUU74LFsl3WXUYPKujkJnJLSEh7p6ekr3jJLhNbL46RlhFX1uO0L6gm1HZ280xBSGVTrfWMc12RSTkFYwTjVAKzy4LJmhSEpalo= ARC-Authentication-Results: i=1; server2.sourceware.org Received: by mail-ed1-x531.google.com with SMTP id 4fb4d7f45d1cf-564372fb762so6620159a12.0 for ; Tue, 27 Feb 2024 11:11:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=baylibre-com.20230601.gappssmtp.com; s=20230601; t=1709061092; x=1709665892; darn=gcc.gnu.org; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:from:to:cc:subject:date:message-id:reply-to; bh=FF+hk4JKOtKVy0nMH6rQR0iyGMckMxB4kQVblcaTe44=; b=px+CsdfV1M9OXPq2mKuVNsyY8bUZS49DJRqt68cD6gAW/ZMcDz9JG8PHdSX3e4BJIP pm/VtDXIavngJ68zuNQuGNNbGhxaj6Xr6Oc0m4QLGksuSSHdKb8pmmXuJ4xBGpgtjVJn 7W41Lam5lCo3EJE3zFhuy2hS6p+bQ9Ddrvs5zqxxxcTqe1xntaukiMj/ZRuLDH8OxTSE Vkn/3BSyhPZCce/8WJXZNdJxdsWLLPE/XV8DC6b/PPtTZ7cdc2vV594keZU08shE6eLz RQfUCLXt5/Lne4I/Mf5SXwdHFuTwk+iKBNAvvHAIoaJNY8/D879TZpcicbH5MmnEgss/ NUkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1709061092; x=1709665892; h=subject:from:to:content-language:user-agent:mime-version:date :message-id:x-gm-message-state:from:to:cc:subject:date:message-id :reply-to; bh=FF+hk4JKOtKVy0nMH6rQR0iyGMckMxB4kQVblcaTe44=; b=eoHnAWeibPz/XW1P2C8Rq0CfU3kCWnaC0EWAXPuCpF9mN0rRp09b7fJNV+AtFXeEGf r+MhvzyRgCEvCf12XuZHACgWPfDbI4jGBbl/BZBC1iU9ZUGsa6z6jTczuVdTchmh+gwR O99SP0PFTccTyfSKSqj1/SGTJB4S7Dd66y/XSp8VPWS5Dw8usYXzztcL1H4OIU2z+xcR p4tO2jrRlyRlcncIA+hNuXzG93LmilxzgbnmIaz7Z3XIPlXmhgFQBj9YHIPmuSSQoRhf uptk+bLeTNFrRt3Hp1OBA7ByOp3SOneY0GbEQQz18ZS3jjeAlnJGPJRC/+eQg+jCbeqj viuA== X-Gm-Message-State: AOJu0YwtO6WwK8KJTDXkcseCNMtR0jx1XL6uVgf41p+ZkJzgWsP298Z4 8Ry/1FX4BitdNYEW1s4lCUIhaQQ2QdOkH7ZGQSpPnug49UzTeCIbRuCxBjfOQd32Gvjko5VIv70 ndi8BkQ== X-Google-Smtp-Source: AGHT+IFASgZnIzlRLRJza66acLdLwz9U6yC3nuDc4lH8GWytNmPPMuRqOfJ0T6IEht6Kd3L11VWFig== X-Received: by 2002:a17:906:241a:b0:a43:bb3b:3b53 with SMTP id z26-20020a170906241a00b00a43bb3b3b53mr1698966eja.47.1709061092180; Tue, 27 Feb 2024 11:11:32 -0800 (PST) Received: from ?IPV6:2001:16b8:2aaa:b100:c567:5d7d:c7b8:4efc? (200116b82aaab100c5675d7dc7b84efc.dip.versatel-1u1.de. [2001:16b8:2aaa:b100:c567:5d7d:c7b8:4efc]) by smtp.gmail.com with ESMTPSA id rf23-20020a1709076a1700b00a43e47c8c97sm147167ejc.173.2024.02.27.11.11.31 (version=TLS1_3 cipher=TLS_AES_128_GCM_SHA256 bits=128/128); Tue, 27 Feb 2024 11:11:31 -0800 (PST) Message-ID: <1b776e22-d01f-4469-a1f7-7230708e997c@baylibre.com> Date: Tue, 27 Feb 2024 20:11:30 +0100 MIME-Version: 1.0 User-Agent: Mozilla Thunderbird Content-Language: en-US To: gcc-patches , Thomas Schwinge From: Tobias Burnus Subject: [Patch] OpenACC: Update libgomp.texi + openacc{.f90,_lib.h} for 3.1 arg-name changes X-Spam-Status: No, score=-11.3 required=5.0 tests=BAYES_00, DKIM_SIGNED, DKIM_VALID, GIT_PATCH_0, RCVD_IN_DNSWL_NONE, SPF_HELO_NONE, SPF_PASS, TXREP, T_SCC_BODY_TEXT_LINE autolearn=ham autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on server2.sourceware.org X-BeenThere: gcc-patches@gcc.gnu.org X-Mailman-Version: 2.1.30 Precedence: list List-Id: Gcc-patches mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: gcc-patches-bounces+patchwork=sourceware.org@gcc.gnu.org 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 ... 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(-) 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